diff --git a/vtk/.gitignore b/vtk/.gitignore new file mode 100644 index 0000000..ea37cb8 --- /dev/null +++ b/vtk/.gitignore @@ -0,0 +1,7 @@ +.DS_Store +src/.DS_Store +src/.cache +src/build +.idea +src/cmake-build-debug +compile_commands.json \ No newline at end of file diff --git a/vtk/README.md b/vtk/README.md new file mode 100644 index 0000000..8f87e04 --- /dev/null +++ b/vtk/README.md @@ -0,0 +1,34 @@ +## Vtk +This folder contains the Vtk program which actually displays the simulated data. The code is driven by the `Program` class, which contains the upper level of the vtk pipeline: the class has attributes for a vtkRenderWindow and vtkRenderWindowInteractor. vtkRenderers are managed through an abstract `Layer` class, which the program keeps track of trough a vector attribute. + +Each layer implementation contains and manages one vtkRenderer, this includes managing which layer of the vtkrenderwindow ths layer renders to. Currently implemented are three such layers: + * the `BackgroundImage` class reads in image data and displays this to the screen on the 0th layer - the background. + * the `EGlyphLayer` class renders a visualization of the Eulerian flow-velocities as a grid of arrow-glyphs (in which the direction and length of the glyph represents the direction and strength of the velocity at that point). Right now it spoofs the data for these glyphs, but this class will interface with the code for reading h5 data to accurately display the velocities at a given timestamp. + * the `LGlyphLayer` class renders a given set of particles as circular glyphs. These particles are advected according to an advection function, which in this implementation is spoofed. Like the EglyphLayer class, this layer will interact with the code for advecting particles according to the actual dataset, to accurately simulate its particles. + +The `LGlyphLayer` deserves some more explanation, as it depends on the `SpawnpointCallback` class to place particles in its dataset. The `SpawnpointCallback` makes use of the vtkCallbackCommand class and the vtk observer pattern to create new particles on mouseclick. It does so through a shared reference to the LGlyphLayer's `data` and `points` attributes, which the SpawnpointCallback then edits directlr. + +The program also adds a second observer to the vtk pattern through the `TimerCallbackCommand`. This class subscribes to a vtkTimerEvent to manage the simulation of the program. To this end the TimerCallbackCommand has attributes for a timestep (dt) and current time (time). On every callback, the current time is updated according to the dt attribute, and this change is propagated to the layers containing the data by use of the program and layer's `updateData()` functions. + + +## Location of data +The data path is hardcoded such that the following tree structure is assumed: +``` +data/ + grid.h5 + hydrodynamic_U.h5 + hydrodynamic_V.h5 +interactive-track-and-trace/ + opening-hdf5/ + ... +``` + +## Compiling +Let the current directory be the `src` directory. Run: +```shell +mkdir build +cd build +cmake .. +make +``` + diff --git a/vtk/src/CMakeLists.txt b/vtk/src/CMakeLists.txt new file mode 100644 index 0000000..ef2a3aa --- /dev/null +++ b/vtk/src/CMakeLists.txt @@ -0,0 +1,76 @@ +cmake_minimum_required(VERSION 3.12 FATAL_ERROR) + +project(VtkBase) + +set(CMAKE_EXPORT_COMPILE_COMMANDS ON) + +find_package(VTK COMPONENTS + CommonColor + CommonColor + CommonCore + CommonDataModel + FiltersGeneral + FiltersGeometry + FiltersProgrammable + FiltersSources + ImagingSources + InteractionStyle + IOImage + RenderingContextOpenGL2 + RenderingCore + RenderingCore + RenderingFreeType + RenderingGL2PSOpenGL2 + RenderingOpenGL2) + + +if (NOT VTK_FOUND) + message(FATAL_ERROR "VtkBase: Unable to find the VTK build folder.") +endif() + +# netcdf setup +find_package(netCDF REQUIRED) + +add_executable(VtkBase MACOSX_BUNDLE main.cpp + layers/BackgroundImage.cpp + layers/BackgroundImage.h + layers/EGlyphLayer.cpp + layers/EGlyphLayer.h + layers/Layer.cpp + layers/Layer.h + layers/LGlyphLayer.cpp + layers/LGlyphLayer.h + Program.cpp + Program.h + commands/TimerCallbackCommand.h + commands/TimerCallbackCommand.cpp + commands/SpawnPointCallback.h + commands/SpawnPointCallback.cpp + CartographicTransformation.cpp +) + +execute_process( + COMMAND nc-config --includedir + OUTPUT_VARIABLE NETCDF_INCLUDE_DIR + OUTPUT_STRIP_TRAILING_WHITESPACE +) + +execute_process( + COMMAND ncxx4-config --libdir + OUTPUT_VARIABLE NETCDFCXX_LIB_DIR + OUTPUT_STRIP_TRAILING_WHITESPACE +) + +target_include_directories(VtkBase PUBLIC ${netCDF_INCLUDE_DIR}) + +find_library(NETCDF_LIB NAMES netcdf-cxx4 netcdf_c++4 PATHS ${NETCDFCXX_LIB_DIR} NO_DEFAULT_PATH) + +# Prevent a "command line is too long" failure in Windows. +set(CMAKE_NINJA_FORCE_RESPONSE_FILE "ON" CACHE BOOL "Force Ninja to use response files.") +target_link_libraries(VtkBase ${NETCDF_LIB} ${VTK_LIBRARIES}) + +# vtk_module_autoinit is needed +vtk_module_autoinit( + TARGETS VtkBase + MODULES ${VTK_LIBRARIES} +) diff --git a/vtk/src/CartographicTransformation.cpp b/vtk/src/CartographicTransformation.cpp new file mode 100644 index 0000000..54c528e --- /dev/null +++ b/vtk/src/CartographicTransformation.cpp @@ -0,0 +1,46 @@ +#include "CartographicTransformation.h" +#include +#include +#include + +vtkSmartPointer createNormalisedCamera() { + vtkSmartPointer camera = vtkSmartPointer::New(); + camera->ParallelProjectionOn(); // Enable parallel projection + + camera->SetPosition(0, 0, 1000); // Place the camera above the center + camera->SetFocalPoint(0, 0, 0); // Look at the center + camera->SetViewUp(0, 1, 0); // Set the up vector to be along the Y-axis + camera->SetParallelScale(1); // x,y in [-1, 1] + + return camera; +} + +vtkSmartPointer getCartographicTransformMatrix() { + const double XMin = -15.875; + const double XMax = 12.875; + const double YMin = 46.125; + const double YMax = 62.625; + + double eyeTransform[] = { + 2/(XMax-XMin), 0, 0, -(XMax+XMin)/(XMax-XMin), + 0, 2/(YMax-YMin), 0, -(YMax+YMin)/(YMax-YMin), + 0, 0, 1, 0, + 0, 0, 0, 1 + }; + + auto matrix = vtkSmartPointer::New(); + matrix->DeepCopy(eyeTransform); + return matrix; +} + +// Assumes Normalised camera is used +vtkSmartPointer createCartographicTransformFilter() { + vtkNew transform; + + transform->SetMatrix(getCartographicTransformMatrix()); + + vtkSmartPointer transformFilter = vtkSmartPointer::New(); + transformFilter->SetTransform(transform); + + return transformFilter; +} diff --git a/vtk/src/CartographicTransformation.h b/vtk/src/CartographicTransformation.h new file mode 100644 index 0000000..56ffbeb --- /dev/null +++ b/vtk/src/CartographicTransformation.h @@ -0,0 +1,30 @@ +#include +#include + +#ifndef VTKBASE_NORMALISEDCARTOGRAPHICCAMERA_H +#define VTKBASE_NORMALISEDCARTOGRAPHICCAMERA_H + +#endif //VTKBASE_NORMALISEDCARTOGRAPHICCAMERA_H + +/** + * Constructs a orthographically projected camera that looks at the square x,y in [-1, 1] with z = 0 and w = 1. + * The space [-1,1] x [-1,1] x {0} will be referred to as the normalised space. + * @return pointer to camera + */ +vtkSmartPointer createNormalisedCamera(); + +/** + * Constructs a 4x4 projection matrix that maps homogenious (longitude, latitude, 0, 1) points + * to the normalised space. + * TODO: This will soon require UVGrid as a parameter after the advection code is merged properly. + * TODO: This transformation has room for improvement see: + * https://github.com/MakeNEnjoy/interactive-track-and-trace/issues/12 + * @return pointer to 4x4 matrix + */ +vtkSmartPointer getCartographicTransformMatrix(); + +/** + * Convenience function that converts the 4x4 projection matrix into a vtkTransformFilter + * @return pointer to transform filter + */ +vtkSmartPointer createCartographicTransformFilter(); \ No newline at end of file diff --git a/vtk/src/Program.cpp b/vtk/src/Program.cpp new file mode 100644 index 0000000..f5d1a93 --- /dev/null +++ b/vtk/src/Program.cpp @@ -0,0 +1,86 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "Program.h" +#include "commands/TimerCallbackCommand.h" +#include "commands/SpawnPointCallback.h" + +void Program::setWinProperties() { + this->win->SetWindowName("Simulation"); + this->win->SetSize(661, 661); + this->win->SetDesiredUpdateRate(60); + + this->interact->SetRenderWindow(this->win); + this->interact->Initialize(); + + vtkNew style; + interact->SetInteractorStyle(style); +} + +void Program::setupTimer() { + auto callback = vtkSmartPointer::New(this); + callback->SetClientData(this); + this->interact->AddObserver(vtkCommand::TimerEvent, callback); + this->interact->CreateRepeatingTimer(17); // 60 fps == 1000 / 60 == 16.7 ms per frame +} + +Program::Program() { + this->win = vtkSmartPointer::New(); + this->interact = vtkSmartPointer::New(); + + this->win->SetNumberOfLayers(0); + setWinProperties(); + setupTimer(); +} + + +void Program::addLayer(Layer *layer) { + this->layers.push_back(layer); + this->win->AddRenderer(layer->getLayer()); + this->win->SetNumberOfLayers(this->win->GetNumberOfLayers() + 1); +} + +void Program::removeLayer(Layer *layer) { + this->win->RemoveRenderer(layer->getLayer()); + + auto it = std::find(this->layers.begin(), this->layers.end(), layer); + if (it != this->layers.end()) { + this->layers.erase(it); + this->win->SetNumberOfLayers(this->win->GetNumberOfLayers() - 1); + } +} + +void Program::updateData(int t) { + win->Render(); + for (Layer *l: layers) { + l->updateData(t); + } +} + +void Program::setupInteractions() { + for (Layer *l: layers) { + l->addObservers(interact); + } +} + +void Program::render() { + setupInteractions(); + win->Render(); + interact->Start(); +} diff --git a/vtk/src/Program.h b/vtk/src/Program.h new file mode 100644 index 0000000..4097e4c --- /dev/null +++ b/vtk/src/Program.h @@ -0,0 +1,68 @@ +#ifndef PROGRAM_H +#define PROGRAM_H + +#include +#include +#include + +#include "layers/Layer.h" +#include "commands/SpawnPointCallback.h" + +/** This class manages the upper levels of the vtk pipeline; it has attributes for the vtkrenderWindow and a vector of Layers to represent a variable number of vtkRenderers. + * It can also set up a vtkTimer by connecting an instance of TimerCallbackCommand with its contained vtkRenderWindowInteractor. + */ +class Program { +private: + /** This attribute models a variable number of vtkRenderers, managed through the abstract Layer class. + */ + std::vector layers; + + /** The window this program's layers render to. + */ + vtkSmartPointer win; + + /** The interactor through which the layers can interact with the window. + */ + vtkSmartPointer interact; + + /** This function sets some default properties on the vtkRenderWindow. Extracted to its' own function to keep the constructor from becoming cluttered. + */ + void setWinProperties(); + + /** This function sets up and connects a TimerCallbackCommand with the program. + */ + void setupTimer(); + + void setupInteractions(); + +public: + /** Constructor. + */ + Program(); + + /** This function adds a new layer (and thus vtkRenderer) to the program. + * The layer is expected to set its own position in the vtkRenderWindow layer system. + * @param layer : pointer to the layer to add. + */ + void addLayer(Layer *layer); + + /** This function removes a given layer from the vtkRenderWindow and layers vector. + * If the given layer is not actually in the program, nothing happens. + * @param layer : the layer to removeLayer + */ + void removeLayer(Layer *layer); + + /** This function updates the data for the associated layers to the given timestamp. + * Also updates the renderWindow. + * @param t : the timestamp to update the data to. + */ + void updateData(int t); + + /** + * This function renders the vtkRenderWindow for the first time. + * Only call this function once! + */ + void render(); +}; + +#endif diff --git a/vtk/src/commands/SpawnPointCallback.cpp b/vtk/src/commands/SpawnPointCallback.cpp new file mode 100644 index 0000000..e29d190 --- /dev/null +++ b/vtk/src/commands/SpawnPointCallback.cpp @@ -0,0 +1,77 @@ +#include "SpawnPointCallback.h" + +#include +#include +#include +#include +#include +#include + +#include "../CartographicTransformation.h" + +void convertDisplayToWorld(vtkRenderer* renderer, int x, int y, double *worldPos) { + double displayPos[3] = {static_cast(x), static_cast(y), 0.0}; + renderer->SetDisplayPoint(displayPos); + renderer->DisplayToWorld(); + renderer->GetWorldPoint(worldPos); +} + +void SpawnPointCallback::Execute(vtkObject *caller, unsigned long evId, void *callData) { + // Note the use of reinterpret_cast to cast the caller to the expected type. + auto interactor = reinterpret_cast(caller); + + if (evId == vtkCommand::LeftButtonPressEvent) { + dragging = true; + } + if (evId == vtkCommand::LeftButtonReleaseEvent) { + dragging = false; + } + if (!dragging) { + return; + } + + int x, y; + interactor->GetEventPosition(x, y); + + double worldPos[4] = {2, 0 ,0, 0}; + double displayPos[3] = {static_cast(x), static_cast(y), 0.0}; + ren->SetDisplayPoint(displayPos); + ren->DisplayToWorld(); + ren->GetWorldPoint(worldPos); + inverseCartographicProjection->MultiplyPoint(worldPos, worldPos); + cout << "clicked on lon = " << worldPos[0] << " and lat = " << worldPos[1] << endl; + + vtkIdType id = points->InsertNextPoint(worldPos[0], worldPos[1], 0); + data->SetPoints(points); + + vtkSmartPointer vertex = vtkSmartPointer::New(); + vertex->GetPointIds()->SetId(0, id); + + vtkSmartPointer vertices = vtkSmartPointer::New(); + vertices->InsertNextCell(vertex); + data->SetVerts(vertices); +// data->Modified(); // These might be needed im not sure. +// ren->GetRenderWindow()->Render(); +} + + +SpawnPointCallback::SpawnPointCallback() : data(nullptr), points(nullptr), inverseCartographicProjection(nullptr) { + inverseCartographicProjection = getCartographicTransformMatrix(); + inverseCartographicProjection->Invert(); +} + +SpawnPointCallback *SpawnPointCallback::New() { + return new SpawnPointCallback; +} + +void SpawnPointCallback::setData(const vtkSmartPointer &data) { + this->data = data; +} + +void SpawnPointCallback::setPoints(const vtkSmartPointer &points) { + this->points = points; +} + +void SpawnPointCallback::setRen(const vtkSmartPointer &ren) { + this->ren = ren; +} diff --git a/vtk/src/commands/SpawnPointCallback.h b/vtk/src/commands/SpawnPointCallback.h new file mode 100644 index 0000000..bef6ca4 --- /dev/null +++ b/vtk/src/commands/SpawnPointCallback.h @@ -0,0 +1,33 @@ +#ifndef VTKBASE_SPAWNPOINTCALLBACK_H +#define VTKBASE_SPAWNPOINTCALLBACK_H + + +#include +#include +#include +#include +#include + +class SpawnPointCallback : public vtkCallbackCommand { + +public: + static SpawnPointCallback *New(); + SpawnPointCallback(); + + void setPoints(const vtkSmartPointer &points); + + void setData(const vtkSmartPointer &data); + + void setRen(const vtkSmartPointer &ren); +private: + vtkSmartPointer data; + vtkSmartPointer points; + vtkSmartPointer ren; + vtkSmartPointer inverseCartographicProjection; + + void Execute(vtkObject *caller, unsigned long evId, void *callData) override; + bool dragging = false; +}; + + +#endif //VTKBASE_SPAWNPOINTCALLBACK_H diff --git a/vtk/src/commands/TimerCallbackCommand.cpp b/vtk/src/commands/TimerCallbackCommand.cpp new file mode 100644 index 0000000..94e9de9 --- /dev/null +++ b/vtk/src/commands/TimerCallbackCommand.cpp @@ -0,0 +1,28 @@ +#include "TimerCallbackCommand.h" +#include "../Program.h" + + +TimerCallbackCommand::TimerCallbackCommand() : dt(3600), maxTime(3600*24*365), time(0) {} + +TimerCallbackCommand* TimerCallbackCommand::New(Program *program) { + TimerCallbackCommand *cb = new TimerCallbackCommand(); + cb->setProgram(program); + return cb; +} + +void TimerCallbackCommand::Execute(vtkObject* caller, unsigned long eventId, void* vtkNotUsed(callData)) { + this->time += this->dt; + + if (this->time >= this->maxTime) { + return; + // TODO: how do we deal with reaching the end of the simulated dataset? Do we just stop simulating, loop back around? What about the location of the particles in this case? Just some ideas to consider, but we should iron this out pretty soon. + } + + this->program->updateData(this->time); +} + + + +void TimerCallbackCommand::setProgram(Program *program) { + this->program = program; +} diff --git a/vtk/src/commands/TimerCallbackCommand.h b/vtk/src/commands/TimerCallbackCommand.h new file mode 100644 index 0000000..618c7bf --- /dev/null +++ b/vtk/src/commands/TimerCallbackCommand.h @@ -0,0 +1,22 @@ +#ifndef TIMERCALLBACKCOMMAND_H +#define TIMERCALLBACKCOMMAND_H + +#include +#include "../Program.h" + +class TimerCallbackCommand : public vtkCallbackCommand { +public: + TimerCallbackCommand(); + static TimerCallbackCommand* New(Program *program); + void Execute(vtkObject* caller, unsigned long eventId, void* vtkNotUsed(callData)) override; + + void setProgram(Program *program); + +private: + int time; + int dt; + int maxTime; + Program *program; +}; + +#endif diff --git a/vtk/src/layers/BackgroundImage.cpp b/vtk/src/layers/BackgroundImage.cpp new file mode 100644 index 0000000..780eaae --- /dev/null +++ b/vtk/src/layers/BackgroundImage.cpp @@ -0,0 +1,62 @@ +#include "BackgroundImage.h" +#include +#include +#include +#include + +using std::string; + +BackgroundImage::BackgroundImage(string imagePath) : imagePath(imagePath) { + this->ren = vtkSmartPointer::New(); + this->ren->SetLayer(0); + this->ren->InteractiveOff(); + updateImage(); +} + + +void BackgroundImage::updateImage() { + vtkSmartPointer imageData; + + vtkSmartPointer imageReader; + + imageReader.TakeReference(this->readerFactory->CreateImageReader2(this->imagePath.c_str())); + imageReader->SetFileName(this->imagePath.c_str()); + imageReader->Update(); + imageData = imageReader->GetOutput(); + + vtkNew imageActor; + imageActor->SetInputData(imageData); + + this->ren->AddActor(imageActor); + + + // camera stuff + // essentially sets the camera to the middle of the background, and points it at the background + // TODO: extract this to its own function, separate from the background class. + double origin[3], spacing[3]; + int extent[6]; + imageData->GetOrigin(origin); + imageData->GetSpacing(spacing); + imageData->GetExtent(extent); + + vtkCamera *camera = this->ren->GetActiveCamera(); + camera->ParallelProjectionOn(); + + double xc = origin[0] + 0.5 * (extent[0] + extent[1]) * spacing[0]; + double yc = origin[1] + 0.5 * (extent[2] + extent[3]) * spacing[1]; + double yd = (extent[3] - extent[2] + 1) * spacing[1]; + double d = camera->GetDistance(); + camera->SetParallelScale(0.5 * yd); + camera->SetFocalPoint(xc, yc, 0.0); + camera->SetPosition(xc, yc, d); +} + + +string BackgroundImage::getImagePath() { + return this->imagePath; +} + +void BackgroundImage::setImagePath(string imagePath) { + this->imagePath = imagePath; + updateImage(); +} diff --git a/vtk/src/layers/BackgroundImage.h b/vtk/src/layers/BackgroundImage.h new file mode 100644 index 0000000..1061189 --- /dev/null +++ b/vtk/src/layers/BackgroundImage.h @@ -0,0 +1,37 @@ +#ifndef BACKGROUND_H +#define BACKGROUND_H + +#include "Layer.h" +#include + +/** Implements the Layer class for the case of a background image. + * Specifically, reads a backgroundImage given by the imagePath attribute and puts it on layer 0. + */ +class BackgroundImage : public Layer { +private: + std::string imagePath; + vtkSmartPointer readerFactory; + + /** This private function updates the background image using the imagePath attribute. + */ + void updateImage(); + + +public: + /** Constructor. + * @param imagePath : String to the path of the image to use as background. + */ + BackgroundImage(std::string imagePath); + + /** Getter. + * @return the imagePath attribute. + */ + std::string getImagePath(); + + /** Setter. Can be used to change the background image + * @param imagePath : String to the path of the new image to use. + */ + void setImagePath(std::string imagePath); +}; + +#endif diff --git a/vtk/src/layers/EGlyphLayer.cpp b/vtk/src/layers/EGlyphLayer.cpp new file mode 100644 index 0000000..cb91825 --- /dev/null +++ b/vtk/src/layers/EGlyphLayer.cpp @@ -0,0 +1,124 @@ +#include "EGlyphLayer.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "../CartographicTransformation.h" + +using namespace netCDF; +using namespace std; + +template +vector getVarVector(const NcVar &var) { + int length = 1; + for (NcDim dim : var.getDims()) { + length *= dim.getSize(); + } + + vector vec(length); + + var.getVar(vec.data()); + + return vec; +} + +tuple, vector, vector> readGrid() { + netCDF::NcFile data("../../../../data/grid.h5", netCDF::NcFile::read); + multimap< string, NcVar > vars = data.getVars(); + vector time = getVarVector(vars.find("times")->second); + vector longitude = getVarVector(vars.find("longitude")->second); + vector latitude = getVarVector(vars.find("latitude")->second); + + return {time, latitude, longitude}; +} + + +EGlyphLayer::EGlyphLayer() { + this->ren = vtkSmartPointer::New(); + this->ren->SetLayer(1); + this->ren->InteractiveOff(); + + this->data = vtkSmartPointer::New(); + this->direction = vtkSmartPointer::New(); + this->direction->SetName("direction"); + readCoordinates(); +} + + +void EGlyphLayer::readCoordinates() { + vtkNew points; + auto [times, lats, lons] = readGrid(); // FIXME: import Robin's readData function and use it + this->numLats = lats.size(); + this->numLons = lons.size(); + + this->direction->SetNumberOfComponents(3); + this->direction->SetNumberOfTuples(numLats*numLons); + points->Allocate(numLats*numLons); + + auto camera = createNormalisedCamera(); + ren->SetActiveCamera(camera); + + int i = 0; + for (double lat : lats) { + for (double lon : lons) { + cout << "lon: " << lon << " lat: " << lat << endl; + direction->SetTuple3(i, 0.45, 0.90, 0); //FIXME: read this info from file + points->InsertPoint(i++, lon, lat, 0); + // see also https://vtk.org/doc/nightly/html/classvtkPolyDataMapper2D.html + } + } + this->data->SetPoints(points); + this->data->GetPointData()->AddArray(this->direction); + this->data->GetPointData()->SetActiveVectors("direction"); + + vtkSmartPointer transformFilter = createCartographicTransformFilter(); + transformFilter->SetInputData(data); + + vtkNew arrowSource; + arrowSource->SetGlyphTypeToArrow(); + arrowSource->SetScale(0.2); //TODO: set this properly + arrowSource->Update(); + + vtkNew glyph2D; + glyph2D->SetSourceConnection(arrowSource->GetOutputPort()); + glyph2D->SetInputConnection(transformFilter->GetOutputPort()); + glyph2D->OrientOn(); + glyph2D->ClampingOn(); + glyph2D->SetScaleModeToScaleByVector(); + glyph2D->SetVectorModeToUseVector(); + glyph2D->Update(); + +// vtkNew coordinate; +// coordinate->SetCoordinateSystemToWorld(); + + vtkNew(mapper); + // mapper->SetTransformCoordinate(coordinate); + mapper->SetInputConnection(glyph2D->GetOutputPort()); + mapper->Update(); + + vtkNew actor; + actor->SetMapper(mapper); + + actor->GetProperty()->SetColor(0,0,0); + actor->GetProperty()->SetOpacity(0.2); + + this->ren->AddActor(actor) ; +} + + +void EGlyphLayer::updateData(int t) { + for (int i=0; i < numLats*numLons; i++) { + this->direction->SetTuple3(i, std::cos(t), std::sin(t), 0); // FIXME: fetch data from file. + } + this->direction->Modified(); +} diff --git a/vtk/src/layers/EGlyphLayer.h b/vtk/src/layers/EGlyphLayer.h new file mode 100644 index 0000000..8631f32 --- /dev/null +++ b/vtk/src/layers/EGlyphLayer.h @@ -0,0 +1,35 @@ +#ifndef EGLYPHLAYER_H +#define EGLYPHLAYER_H + +#include "Layer.h" +#include + +/** Implements the Layer class for the case of a Eulerian visualization. + * Specifically, this class models the eulerian flow-fields of the simulation using the 'glyph' mark and 'direction' and 'form' channels to denote direction and strength of velocities. + */ +class EGlyphLayer : public Layer { +private: + vtkSmartPointer data; + vtkSmartPointer direction; + int numLats; + int numLons; + + /** This private function sets up the initial coordinates for the glyphs in the dataset. + * It also reads some initial data to actually display. + */ + void readCoordinates(); + +public: + /** Constructor. + */ + EGlyphLayer(); + + /** updates the glyphs to reflect the given timestamp in the dataset. + * @param t : the time at which to fetch the data. + */ + void updateData(int t); + +}; + + +#endif diff --git a/vtk/src/layers/LGlyphLayer.cpp b/vtk/src/layers/LGlyphLayer.cpp new file mode 100644 index 0000000..845d628 --- /dev/null +++ b/vtk/src/layers/LGlyphLayer.cpp @@ -0,0 +1,105 @@ +#include "LGlyphLayer.h" +#include "../commands/SpawnPointCallback.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "../CartographicTransformation.h" + + +vtkSmartPointer LGlyphLayer::createSpawnPointCallback() { + auto newPointCallBack = vtkSmartPointer::New(); + newPointCallBack->setData(data); + newPointCallBack->setPoints(points); + newPointCallBack->setRen(ren); + return newPointCallBack; +} + +// Further notes; current thinking is to allow tracking a particle's age by using a scalar array in the VtkPolyData. This would be incremented for every tick/updateData function call. +// Another challenge is the concept of beaching; dead particles must not be included in the advect function call (wasted computations), but they should not be outright deleted from the vtkPoints either (we still want to display them). Working Solution: have another array of ints in the vtkPolyData, which tracks for how many calls of UpdateData a given particle has not had its position changed. If this int reaches some treshold (5? 10? 3? needs some testing), exclude the particle from the advect call. +// +// TODO: modelling all this in vtkClasses is workable, but ideally i would want to work with a native C++ class. See if this is doable and feasible. + +LGlyphLayer::LGlyphLayer() { + this->ren = vtkSmartPointer::New(); + this->ren->SetLayer(2); + + this->points = vtkSmartPointer::New(); + this->data = vtkSmartPointer::New(); + this->data->SetPoints(this->points); + + auto camera = createNormalisedCamera(); + ren->SetActiveCamera(camera); + + auto transform = createCartographicTransformFilter(); + + vtkSmartPointer transformFilter = createCartographicTransformFilter(); + transformFilter->SetInputData(data); + + vtkNew circleSource; + circleSource->SetGlyphTypeToCircle(); + circleSource->SetScale(0.05); + circleSource->Update(); + + vtkNew glyph2D; + glyph2D->SetSourceConnection(circleSource->GetOutputPort()); + glyph2D->SetInputConnection(transformFilter->GetOutputPort()); + glyph2D->SetColorModeToColorByScalar(); + glyph2D->Update(); + + vtkNew mapper; + mapper->SetInputConnection(glyph2D->GetOutputPort()); + mapper->Update(); + + vtkNew actor; + actor->SetMapper(mapper); + + this->ren->AddActor(actor); +} + +// creates a few points so we can test the updateData function +void LGlyphLayer::spoofPoints() { + this->points->InsertNextPoint(-4.125, 61.375 , 0); + this->points->InsertNextPoint(6.532949683882039, 53.24308582564463, 0); // Coordinates of Zernike + this->points->InsertNextPoint(5.315307819255385, 60.40001057122271, 0); // Coordinates of Bergen + this->points->InsertNextPoint( 6.646210231365825, 46.52346296009023, 0); // Coordinates of Lausanne + this->points->InsertNextPoint(-6.553894313570932, 62.39522131195857, 0); // Coordinates of the top of the Faroe islands + + this->points->Modified(); +} + +// returns new coords for a point; used to test the updateData function +std::pair advect(int time, double lat, double lon) { + return {lat + 0.01, lon + 0.01}; +} + +void LGlyphLayer::updateData(int t) { + double point[3]; + for (vtkIdType n = 0; n < this->points->GetNumberOfPoints(); n++) { + this->points->GetPoint(n, point); + auto [xNew, yNew] = advect(n, point[0], point[1]); + this->points->SetPoint(n, xNew, yNew, 0); + } + this->points->Modified(); +} + +void LGlyphLayer::addObservers(vtkSmartPointer interactor) { + auto newPointCallBack = vtkSmartPointer::New(); + newPointCallBack->setData(data); + newPointCallBack->setPoints(points); + newPointCallBack->setRen(ren); + interactor->AddObserver(vtkCommand::LeftButtonPressEvent, newPointCallBack); + interactor->AddObserver(vtkCommand::LeftButtonReleaseEvent, newPointCallBack); + interactor->AddObserver(vtkCommand::MouseMoveEvent, newPointCallBack); +} diff --git a/vtk/src/layers/LGlyphLayer.h b/vtk/src/layers/LGlyphLayer.h new file mode 100644 index 0000000..22993b4 --- /dev/null +++ b/vtk/src/layers/LGlyphLayer.h @@ -0,0 +1,38 @@ +#ifndef LGLYPHLAYER_H +#define LGLYPHLAYER_H + +#include "Layer.h" +#include "../commands/SpawnPointCallback.h" +#include +#include + +/** Implements the Layer class for the case of a Lagrangian visualization. + * Specifically, this class models the Lagrangian particles in the simulation using the 'glyph' mark and 'transparency' channel to denote age. + */ +class LGlyphLayer : public Layer { +private: + vtkSmartPointer points; + vtkSmartPointer data; + + + +public: + /** Constructor. + */ + LGlyphLayer(); + + /** This function spoofs a few points in the dataset. Mostly used for testing. + */ + void spoofPoints(); + + /** updates the glyphs to reflect the given timestamp in the dataset. + * @param t : the time at which to fetch the data. + */ + void updateData(int t) override; + + vtkSmartPointer createSpawnPointCallback(); + + void addObservers(vtkSmartPointer interactor) override; +}; + +#endif diff --git a/vtk/src/layers/Layer.cpp b/vtk/src/layers/Layer.cpp new file mode 100644 index 0000000..39073b1 --- /dev/null +++ b/vtk/src/layers/Layer.cpp @@ -0,0 +1,17 @@ +#include "Layer.h" +#include +#include + +using std::string; + +vtkSmartPointer Layer::getLayer() { + return this->ren; +} + +void Layer::updateData(int t) { + // By default, do nothing +} + +void Layer::addObservers(vtkSmartPointer interactor) { + // By default, do nothing +} diff --git a/vtk/src/layers/Layer.h b/vtk/src/layers/Layer.h new file mode 100644 index 0000000..5f6fc32 --- /dev/null +++ b/vtk/src/layers/Layer.h @@ -0,0 +1,32 @@ +#ifndef LAYER_H +#define LAYER_H + +#include +#include + +/** This class represents one abstract layer to be rendered to VTK. + * It exists to manage multiple different layers under the Program class. + */ +class Layer { +protected: + vtkSmartPointer ren; + +public: + /** gets the vtkRenderer to assign it to the vtkRenderWindow of the program class. + * @return pointer to the vtkRenderer of this class. + */ + virtual vtkSmartPointer getLayer(); + + + /** updates the data in the layer to reflect the given timestamp. + * @param t : the timestamp which the data should reflect. + */ + virtual void updateData(int t); + + /** Adds observers to the renderWindowinteractor within which this layer is active. + * @param interactor : pointer to the interactor that observers can be added to. + */ + virtual void addObservers(vtkSmartPointer interactor); +}; + +#endif diff --git a/vtk/src/main.cpp b/vtk/src/main.cpp new file mode 100644 index 0000000..fb89ea4 --- /dev/null +++ b/vtk/src/main.cpp @@ -0,0 +1,32 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "layers/BackgroundImage.h" +#include "layers/EGlyphLayer.h" +#include "layers/LGlyphLayer.h" +#include "Program.h" + +using namespace std; + + +int main() { + auto l = new LGlyphLayer(); + l->spoofPoints(); + + Program *program = new Program(); + program->addLayer(new BackgroundImage("../../../../data/map_661-661.png")); + program->addLayer(new EGlyphLayer()); + program->addLayer(l); + + program->render(); + + return EXIT_SUCCESS; +} + diff --git a/vtk/src/modules.json b/vtk/src/modules.json new file mode 100644 index 0000000..88cd785 --- /dev/null +++ b/vtk/src/modules.json @@ -0,0 +1 @@ +{"modules": {"VTK::WrappingTools": {"library_name": "vtkWrappingTools", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": null, "depends": [], "optional_depends": [], "private_depends": [], "implements": [], "headers": ["vtkParse.h", "vtkParseAttributes.h", "vtkParseData.h", "vtkParseExtras.h", "vtkParseHierarchy.h", "vtkParseMain.h", "vtkParseMangle.h", "vtkParseMerge.h", "vtkParsePreprocess.h", "vtkParseString.h", "vtkParseSystem.h", "vtkParseType.h", "vtkWrap.h", "vtkWrapText.h", "vtkWrappingToolsModule.h"], "licenses": []}, "VTK::ViewsContext2D": {"library_name": "vtkViewsContext2D", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Views", "depends": ["VTK::CommonCore", "VTK::RenderingCore", "VTK::ViewsCore"], "optional_depends": [], "private_depends": ["VTK::RenderingContext2D"], "implements": [], "headers": ["vtkContextInteractorStyle.h", "vtkContextView.h", "vtkViewsContext2DModule.h"], "licenses": []}, "VTK::loguru": {"library_name": "vtkloguru", "description": "", "enabled": true, "implementable": false, "third_party": true, "wrap_exclude": false, "kit": null, "depends": [], "optional_depends": [], "private_depends": [], "implements": [], "headers": ["vtkloguru/loguru.hpp", "vtkloguru/vtkloguru_export.h"], "licenses": []}, "VTK::TestingRendering": {"library_name": "vtkTestingRendering", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": null, "depends": ["VTK::CommonCore", "VTK::RenderingCore", "VTK::TestingCore"], "optional_depends": [], "private_depends": ["VTK::CommonDataModel", "VTK::CommonExecutionModel", "VTK::CommonSystem", "VTK::IOImage", "VTK::ImagingCore", "VTK::vtksys"], "implements": [], "headers": ["vtkMultiBaselineRegressionTest.h", "vtkTesting.h", "vtkTestingInteractor.h", "vtkTestingObjectFactory.h", "vtkTestingRenderingModule.h"], "licenses": []}, "VTK::TestingCore": {"library_name": "vtkTestingCore", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": null, "depends": ["VTK::CommonCore", "VTK::vtksys"], "optional_depends": [], "private_depends": [], "implements": [], "headers": ["vtkPermuteOptions.h", "vtkTestDriver.h", "vtkTestErrorObserver.h", "vtkTestingColors.h", "vtkTestUtilities.h", "vtkWindowsTestUtilities.h"], "licenses": []}, "VTK::vtksys": {"library_name": "vtksys", "description": "", "enabled": true, "implementable": false, "third_party": true, "wrap_exclude": false, "kit": null, "depends": [], "optional_depends": [], "private_depends": [], "implements": [], "headers": [], "licenses": []}, "VTK::ViewsInfovis": {"library_name": "vtkViewsInfovis", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": null, "depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::CommonExecutionModel", "VTK::InteractionStyle", "VTK::RenderingContext2D", "VTK::ViewsCore"], "optional_depends": [], "private_depends": ["VTK::ChartsCore", "VTK::CommonColor", "VTK::CommonTransforms", "VTK::FiltersCore", "VTK::FiltersExtraction", "VTK::FiltersGeneral", "VTK::FiltersGeometry", "VTK::FiltersImaging", "VTK::FiltersModeling", "VTK::FiltersSources", "VTK::FiltersStatistics", "VTK::ImagingGeneral", "VTK::InfovisCore", "VTK::InfovisLayout", "VTK::InteractionWidgets", "VTK::RenderingAnnotation", "VTK::RenderingCore", "VTK::RenderingLabel"], "implements": [], "headers": ["vtkApplyColors.h", "vtkApplyIcons.h", "vtkDendrogramItem.h", "vtkGraphItem.h", "vtkGraphLayoutView.h", "vtkHeatmapItem.h", "vtkHierarchicalGraphPipeline.h", "vtkHierarchicalGraphView.h", "vtkIcicleView.h", "vtkInteractorStyleAreaSelectHover.h", "vtkInteractorStyleTreeMapHover.h", "vtkParallelCoordinatesHistogramRepresentation.h", "vtkParallelCoordinatesRepresentation.h", "vtkParallelCoordinatesView.h", "vtkRenderedGraphRepresentation.h", "vtkRenderedHierarchyRepresentation.h", "vtkRenderedRepresentation.h", "vtkRenderedSurfaceRepresentation.h", "vtkRenderedTreeAreaRepresentation.h", "vtkRenderView.h", "vtkSCurveSpline.h", "vtkTanglegramItem.h", "vtkTreeAreaView.h", "vtkTreeHeatmapItem.h", "vtkTreeMapView.h", "vtkTreeRingView.h", "vtkViewUpdater.h", "vtkViewsInfovisModule.h"], "licenses": []}, "VTK::CommonColor": {"library_name": "vtkCommonColor", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Common", "depends": ["VTK::CommonCore", "VTK::CommonDataModel"], "optional_depends": [], "private_depends": [], "implements": [], "headers": ["vtkColorSeries.h", "vtkNamedColors.h", "vtkCommonColorModule.h"], "licenses": []}, "VTK::RenderingVolumeOpenGL2": {"library_name": "vtkRenderingVolumeOpenGL2", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::OpenGL", "depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::ImagingCore", "VTK::ImagingMath", "VTK::RenderingCore", "VTK::RenderingOpenGL2", "VTK::RenderingVolume"], "optional_depends": [], "private_depends": ["VTK::CommonMath", "VTK::CommonSystem", "VTK::CommonTransforms", "VTK::FiltersCore", "VTK::FiltersGeneral", "VTK::FiltersSources", "VTK::glew", "VTK::opengl", "VTK::vtksys"], "implements": ["VTK::RenderingVolume"], "headers": ["vtkMultiBlockUnstructuredGridVolumeMapper.h", "vtkMultiBlockVolumeMapper.h", "vtkOpenGLGPUVolumeRayCastMapper.h", "vtkOpenGLProjectedTetrahedraMapper.h", "vtkOpenGLRayCastImageDisplayHelper.h", "vtkSmartVolumeMapper.h", "vtkVolumeTexture.h", "vtkRenderingVolumeOpenGL2Module.h"], "licenses": []}, "VTK::glew": {"library_name": "vtkglew", "description": "", "enabled": true, "implementable": false, "third_party": true, "wrap_exclude": false, "kit": null, "depends": ["VTK::opengl"], "optional_depends": [], "private_depends": [], "implements": [], "headers": ["vtkglew/include/GL/glew.h", "vtkglew/include/GL/glxew.h", "vtkglew/include/GL/vtk_glew_mangle.h", "vtkglew/include/GL/wglew.h"], "licenses": []}, "VTK::opengl": {"library_name": "vtkopengl", "description": "", "enabled": true, "implementable": false, "third_party": true, "wrap_exclude": false, "kit": null, "depends": [], "optional_depends": [], "private_depends": [], "implements": [], "headers": [], "licenses": []}, "VTK::RenderingLabel": {"library_name": "vtkRenderingLabel", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Rendering", "depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::CommonExecutionModel", "VTK::RenderingCore", "VTK::RenderingFreeType"], "optional_depends": [], "private_depends": ["VTK::CommonMath", "VTK::CommonSystem", "VTK::CommonTransforms", "VTK::FiltersGeneral", "VTK::octree"], "implements": [], "headers": ["vtkDynamic2DLabelMapper.h", "vtkFreeTypeLabelRenderStrategy.h", "vtkLabeledDataMapper.h", "vtkLabeledTreeMapDataMapper.h", "vtkLabelHierarchy.h", "vtkLabelHierarchyAlgorithm.h", "vtkLabelHierarchyCompositeIterator.h", "vtkLabelHierarchyIterator.h", "vtkLabelPlacementMapper.h", "vtkLabelPlacer.h", "vtkLabelRenderStrategy.h", "vtkLabelSizeCalculator.h", "vtkPointSetToLabelHierarchy.h", "vtkRenderingLabelModule.h"], "licenses": []}, "VTK::octree": {"library_name": "vtkoctree", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": null, "depends": [], "optional_depends": [], "private_depends": [], "implements": [], "headers": ["octree/octree", "octree/octree.h", "octree/octree_cursor.h", "octree/octree_iterator.h", "octree/octree_node.h", "octree/octree_path.h"], "licenses": []}, "VTK::RenderingLOD": {"library_name": "vtkRenderingLOD", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Rendering", "depends": ["VTK::RenderingCore"], "optional_depends": [], "private_depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::CommonExecutionModel", "VTK::CommonMath", "VTK::CommonSystem", "VTK::FiltersCore", "VTK::FiltersModeling"], "implements": [], "headers": ["vtkLODActor.h", "vtkQuadricLODActor.h", "vtkRenderingLODModule.h"], "licenses": []}, "VTK::RenderingLICOpenGL2": {"library_name": "vtkRenderingLICOpenGL2", "description": "", "enabled": true, "implementable": true, "third_party": false, "wrap_exclude": false, "kit": null, "depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::CommonExecutionModel", "VTK::RenderingOpenGL2"], "optional_depends": [], "private_depends": ["VTK::CommonMath", "VTK::CommonSystem", "VTK::IOCore", "VTK::IOLegacy", "VTK::IOXML", "VTK::ImagingCore", "VTK::ImagingSources", "VTK::RenderingCore", "VTK::glew", "VTK::opengl", "VTK::vtksys"], "implements": [], "headers": ["vtkPainterCommunicator.h", "vtkBatchedSurfaceLICMapper.h", "vtkCompositeSurfaceLICMapper.h", "vtkCompositeSurfaceLICMapperDelegator.h", "vtkImageDataLIC2D.h", "vtkLineIntegralConvolution2D.h", "vtkStructuredGridLIC2D.h", "vtkSurfaceLICComposite.h", "vtkSurfaceLICInterface.h", "vtkSurfaceLICMapper.h", "vtkTextureIO.h", "vtkRenderingLICOpenGL2Module.h"], "licenses": []}, "VTK::RenderingImage": {"library_name": "vtkRenderingImage", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Rendering", "depends": ["VTK::CommonExecutionModel", "VTK::RenderingCore"], "optional_depends": [], "private_depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::CommonMath", "VTK::CommonTransforms", "VTK::ImagingCore"], "implements": [], "headers": ["vtkDepthImageToPointCloud.h", "vtkImageResliceMapper.h", "vtkImageSliceCollection.h", "vtkImageStack.h", "vtkRenderingImageModule.h"], "licenses": []}, "VTK::RenderingContextOpenGL2": {"library_name": "vtkRenderingContextOpenGL2", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::OpenGL", "depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::RenderingContext2D", "VTK::RenderingCore", "VTK::RenderingFreeType", "VTK::RenderingOpenGL2"], "optional_depends": [], "private_depends": ["VTK::CommonMath", "VTK::CommonTransforms", "VTK::ImagingCore", "VTK::glew", "VTK::opengl"], "implements": ["VTK::RenderingContext2D"], "headers": ["vtkOpenGLContextActor.h", "vtkOpenGLContextBufferId.h", "vtkOpenGLContextDevice2D.h", "vtkOpenGLContextDevice3D.h", "vtkOpenGLPropItem.h", "vtkRenderingContextOpenGL2Module.h"], "licenses": []}, "VTK::RenderingCellGrid": {"library_name": "vtkRenderingCellGrid", "description": "", "enabled": true, "implementable": true, "third_party": false, "wrap_exclude": false, "kit": "VTK::OpenGL", "depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::FiltersCellGrid", "VTK::RenderingCore", "VTK::RenderingOpenGL2", "VTK::glew"], "optional_depends": [], "private_depends": ["VTK::CommonExecutionModel", "VTK::opengl"], "implements": ["VTK::RenderingCore"], "headers": ["vtkDGOpenGLRenderer.h", "vtkOpenGLCellGridMapper.h", "vtkOpenGLCellGridRenderRequest.h", "vtkRenderingCellGridModule.h"], "licenses": []}, "VTK::IOVeraOut": {"library_name": "vtkIOVeraOut", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::IO", "depends": ["VTK::CommonExecutionModel"], "optional_depends": [], "private_depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::hdf5"], "implements": [], "headers": ["vtkVeraOutReader.h", "vtkIOVeraOutModule.h"], "licenses": []}, "VTK::hdf5": {"library_name": "vtkhdf5", "description": "", "enabled": true, "implementable": false, "third_party": true, "wrap_exclude": false, "kit": null, "depends": [], "optional_depends": ["VTK::mpi"], "private_depends": ["VTK::zlib"], "implements": [], "headers": [], "licenses": []}, "VTK::IOTecplotTable": {"library_name": "vtkIOTecplotTable", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": null, "depends": ["VTK::CommonCore", "VTK::CommonExecutionModel"], "optional_depends": [], "private_depends": ["VTK::CommonDataModel", "VTK::IOCore", "VTK::vtksys", "VTK::utf8"], "implements": [], "headers": ["vtkTecplotTableReader.h", "vtkIOTecplotTableModule.h"], "licenses": []}, "VTK::utf8": {"library_name": "vtkutf8", "description": "", "enabled": true, "implementable": false, "third_party": true, "wrap_exclude": false, "kit": null, "depends": [], "optional_depends": [], "private_depends": [], "implements": [], "headers": [], "licenses": []}, "VTK::IOSegY": {"library_name": "vtkIOSegY", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::IO", "depends": ["VTK::CommonDataModel", "VTK::CommonExecutionModel", "VTK::IOImage"], "optional_depends": [], "private_depends": ["VTK::CommonCore"], "implements": [], "headers": ["vtkSegYReader.h", "vtkIOSegYModule.h"], "licenses": []}, "VTK::IOParallelXML": {"library_name": "vtkIOParallelXML", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Parallel", "depends": ["VTK::CommonCore", "VTK::IOXML"], "optional_depends": [], "private_depends": ["VTK::CommonDataModel", "VTK::CommonExecutionModel", "VTK::CommonMisc", "VTK::IOCore", "VTK::ParallelCore", "VTK::vtksys"], "implements": [], "headers": ["vtkXMLCompositeDataSetWriterHelper.h", "vtkXMLDataWriterHelper.h", "vtkXMLPartitionedDataSetCollectionWriter.h", "vtkXMLPartitionedDataSetWriter.h", "vtkXMLWriter2.h", "vtkXMLPDataObjectWriter.h", "vtkXMLPDataSetWriter.h", "vtkXMLPDataWriter.h", "vtkXMLPHierarchicalBoxDataWriter.h", "vtkXMLPHyperTreeGridWriter.h", "vtkXMLPImageDataWriter.h", "vtkXMLPMultiBlockDataWriter.h", "vtkXMLPPolyDataWriter.h", "vtkXMLPRectilinearGridWriter.h", "vtkXMLPStructuredDataWriter.h", "vtkXMLPStructuredGridWriter.h", "vtkXMLPTableWriter.h", "vtkXMLPUniformGridAMRWriter.h", "vtkXMLPUnstructuredDataWriter.h", "vtkXMLPUnstructuredGridWriter.h", "vtkIOParallelXMLModule.h"], "licenses": []}, "VTK::IOPLY": {"library_name": "vtkIOPLY", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::IO", "depends": ["VTK::CommonCore", "VTK::IOCore"], "optional_depends": [], "private_depends": ["VTK::CommonDataModel", "VTK::CommonMisc", "VTK::vtksys"], "implements": [], "headers": ["vtkPLY.h", "vtkPLYReader.h", "vtkPLYWriter.h", "vtkIOPLYModule.h"], "licenses": []}, "VTK::IOOggTheora": {"library_name": "vtkIOOggTheora", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::IO", "depends": ["VTK::CommonExecutionModel", "VTK::IOMovie"], "optional_depends": [], "private_depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::CommonMisc", "VTK::CommonSystem", "VTK::theora"], "implements": [], "headers": ["vtkOggTheoraWriter.h", "vtkIOOggTheoraModule.h"], "licenses": []}, "VTK::theora": {"library_name": "vtktheora", "description": "", "enabled": true, "implementable": false, "third_party": true, "wrap_exclude": false, "kit": null, "depends": ["VTK::ogg"], "optional_depends": [], "private_depends": [], "implements": [], "headers": ["vtktheora/include/theora/codec.h", "vtktheora/include/theora/theora.h", "vtktheora/include/theora/theoradec.h", "vtktheora/include/theora/theoraenc.h", "vtktheora/include/theora/vtk_theora_mangle.h", "vtktheora/vtktheora_export.h"], "licenses": []}, "VTK::ogg": {"library_name": "vtkogg", "description": "", "enabled": true, "implementable": false, "third_party": true, "wrap_exclude": false, "kit": null, "depends": [], "optional_depends": [], "private_depends": [], "implements": [], "headers": ["vtkogg/include/ogg/config_types.h", "vtkogg/include/ogg/ogg.h", "vtkogg/include/ogg/os_types.h", "vtkogg/include/ogg/vtk_ogg_mangle.h", "vtkogg/include/ogg/vtkogg_export.h"], "licenses": []}, "VTK::IONetCDF": {"library_name": "vtkIONetCDF", "description": "", "enabled": true, "implementable": true, "third_party": false, "wrap_exclude": false, "kit": "VTK::IO", "depends": ["VTK::CommonCore", "VTK::CommonExecutionModel", "VTK::IOCore"], "optional_depends": [], "private_depends": ["VTK::CommonDataModel", "VTK::netcdf", "VTK::vtksys", "VTK::libproj"], "implements": [], "headers": ["vtkMPASReader.h", "vtkNetCDFCAMReader.h", "vtkNetCDFCFReader.h", "vtkNetCDFCFWriter.h", "vtkNetCDFPOPReader.h", "vtkNetCDFReader.h", "vtkNetCDFUGRIDReader.h", "vtkSLACParticleReader.h", "vtkSLACReader.h", "vtkIONetCDFModule.h"], "licenses": []}, "VTK::netcdf": {"library_name": "vtknetcdf", "description": "", "enabled": true, "implementable": false, "third_party": true, "wrap_exclude": false, "kit": null, "depends": ["VTK::hdf5"], "optional_depends": ["VTK::mpi"], "private_depends": [], "implements": [], "headers": ["vtknetcdf/include/netcdf.h", "vtknetcdf/include/netcdf_filter_build.h", "vtknetcdf/include/vtk_netcdf_mangle.h", "vtknetcdf/include/netcdf_dispatch.h", "vtknetcdf/include/netcdf_meta.h", "vtknetcdf/vtk_netcdf_config.h"], "licenses": []}, "VTK::libproj": {"library_name": "vtklibproj", "description": "", "enabled": true, "implementable": false, "third_party": true, "wrap_exclude": false, "kit": null, "depends": ["VTK::nlohmannjson"], "optional_depends": [], "private_depends": ["VTK::sqlite"], "implements": [], "headers": ["vtklibproj/src/proj.h", "vtklibproj/src/proj_experimental.h", "vtklibproj/src/proj_constants.h", "vtklibproj/src/geodesic.h", "vtklibproj/src/vtk_libproj_mangle.h", "vtklibproj/src/vtklibproj_export.h"], "licenses": []}, "VTK::IOMotionFX": {"library_name": "vtkIOMotionFX", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": null, "depends": ["VTK::CommonExecutionModel"], "optional_depends": [], "private_depends": ["VTK::CommonDataModel", "VTK::CommonMisc", "VTK::IOGeometry", "VTK::pegtl", "VTK::vtksys"], "implements": [], "headers": ["vtkMotionFXCFGReader.h", "vtkIOMotionFXModule.h"], "licenses": []}, "VTK::pegtl": {"library_name": "vtkpegtl", "description": "", "enabled": true, "implementable": false, "third_party": true, "wrap_exclude": false, "kit": null, "depends": [], "optional_depends": [], "private_depends": [], "implements": [], "headers": [], "licenses": []}, "VTK::IOParallel": {"library_name": "vtkIOParallel", "description": "", "enabled": true, "implementable": true, "third_party": false, "wrap_exclude": false, "kit": "VTK::Parallel", "depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::CommonExecutionModel", "VTK::IOCore", "VTK::IOGeometry", "VTK::IOImage", "VTK::IOLegacy", "VTK::jsoncpp"], "optional_depends": [], "private_depends": ["VTK::CommonMisc", "VTK::CommonSystem", "VTK::FiltersCore", "VTK::FiltersExtraction", "VTK::FiltersParallel", "VTK::ParallelCore", "VTK::vtksys"], "implements": [], "headers": ["vtkEnSightWriter.h", "vtkMultiBlockPLOT3DReader.h", "vtkNek5000Reader.h", "vtkPChacoReader.h", "vtkPDataSetReader.h", "vtkPDataSetWriter.h", "vtkPImageWriter.h", "vtkPlot3DMetaReader.h", "vtkPOpenFOAMReader.h", "vtkIOParallelModule.h"], "licenses": []}, "VTK::jsoncpp": {"library_name": "vtkjsoncpp", "description": "", "enabled": true, "implementable": false, "third_party": true, "wrap_exclude": false, "kit": null, "depends": [], "optional_depends": [], "private_depends": [], "implements": [], "headers": ["vtkjsoncpp/json/json-forwards.h", "vtkjsoncpp/json/json.h", "vtkjsoncpp/json/vtkjsoncpp_config.h"], "licenses": []}, "VTK::IOMINC": {"library_name": "vtkIOMINC", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": null, "depends": ["VTK::CommonCore", "VTK::CommonExecutionModel", "VTK::IOCore", "VTK::IOImage"], "optional_depends": [], "private_depends": ["VTK::CommonDataModel", "VTK::CommonMath", "VTK::CommonMisc", "VTK::CommonTransforms", "VTK::FiltersHybrid", "VTK::RenderingCore", "VTK::netcdf", "VTK::vtksys"], "implements": [], "headers": ["vtkMINC.h", "vtkMINCImageAttributes.h", "vtkMINCImageReader.h", "vtkMINCImageWriter.h", "vtkMNIObjectReader.h", "vtkMNIObjectWriter.h", "vtkMNITagPointReader.h", "vtkMNITagPointWriter.h", "vtkMNITransformReader.h", "vtkMNITransformWriter.h", "vtkIOMINCModule.h"], "licenses": []}, "VTK::IOLSDyna": {"library_name": "vtkIOLSDyna", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::IO", "depends": ["VTK::CommonCore", "VTK::CommonExecutionModel", "VTK::IOXMLParser"], "optional_depends": [], "private_depends": ["VTK::CommonDataModel", "VTK::vtksys"], "implements": [], "headers": ["LSDynaFamily.h", "LSDynaMetaData.h", "vtkLSDynaReader.h", "vtkLSDynaSummaryParser.h", "vtkIOLSDynaModule.h"], "licenses": []}, "VTK::IOInfovis": {"library_name": "vtkIOInfovis", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": null, "depends": ["VTK::CommonCore", "VTK::CommonExecutionModel", "VTK::IOLegacy", "VTK::IOXML"], "optional_depends": [], "private_depends": ["VTK::CommonDataModel", "VTK::CommonMisc", "VTK::IOCore", "VTK::IOXMLParser", "VTK::InfovisCore", "VTK::libxml2", "VTK::vtksys", "VTK::utf8"], "implements": [], "headers": ["vtkBiomTableReader.h", "vtkChacoGraphReader.h", "vtkDelimitedTextReader.h", "vtkDIMACSGraphReader.h", "vtkDIMACSGraphWriter.h", "vtkFixedWidthTextReader.h", "vtkISIReader.h", "vtkMultiNewickTreeReader.h", "vtkNewickTreeReader.h", "vtkNewickTreeWriter.h", "vtkPhyloXMLTreeReader.h", "vtkPhyloXMLTreeWriter.h", "vtkRISReader.h", "vtkTemporalDelimitedTextReader.h", "vtkTulipReader.h", "vtkXGMLReader.h", "vtkXMLTreeReader.h", "vtkIOInfovisModule.h"], "licenses": []}, "VTK::libxml2": {"library_name": "vtklibxml2", "description": "", "enabled": true, "implementable": false, "third_party": true, "wrap_exclude": false, "kit": null, "depends": ["VTK::zlib"], "optional_depends": [], "private_depends": [], "implements": [], "headers": ["vtklibxml2/include/libxml/c14n.h", "vtklibxml2/include/libxml/catalog.h", "vtklibxml2/include/libxml/chvalid.h", "vtklibxml2/include/libxml/debugXML.h", "vtklibxml2/include/libxml/dict.h", "vtklibxml2/include/libxml/encoding.h", "vtklibxml2/include/libxml/entities.h", "vtklibxml2/include/libxml/globals.h", "vtklibxml2/include/libxml/hash.h", "vtklibxml2/include/libxml/HTMLparser.h", "vtklibxml2/include/libxml/HTMLtree.h", "vtklibxml2/include/libxml/list.h", "vtklibxml2/include/libxml/nanoftp.h", "vtklibxml2/include/libxml/nanohttp.h", "vtklibxml2/include/libxml/parser.h", "vtklibxml2/include/libxml/parserInternals.h", "vtklibxml2/include/libxml/pattern.h", "vtklibxml2/include/libxml/relaxng.h", "vtklibxml2/include/libxml/SAX.h", "vtklibxml2/include/libxml/SAX2.h", "vtklibxml2/include/libxml/schemasInternals.h", "vtklibxml2/include/libxml/schematron.h", "vtklibxml2/include/libxml/threads.h", "vtklibxml2/include/libxml/tree.h", "vtklibxml2/include/libxml/uri.h", "vtklibxml2/include/libxml/valid.h", "vtklibxml2/include/libxml/vtk_libxml2_mangle.h", "vtklibxml2/include/libxml/xinclude.h", "vtklibxml2/include/libxml/xlink.h", "vtklibxml2/include/libxml/xmlIO.h", "vtklibxml2/include/libxml/xmlautomata.h", "vtklibxml2/include/libxml/xmlerror.h", "vtklibxml2/include/libxml/xmlexports.h", "vtklibxml2/include/libxml/xmlmemory.h", "vtklibxml2/include/libxml/xmlmodule.h", "vtklibxml2/include/libxml/xmlreader.h", "vtklibxml2/include/libxml/xmlregexp.h", "vtklibxml2/include/libxml/xmlsave.h", "vtklibxml2/include/libxml/xmlschemas.h", "vtklibxml2/include/libxml/xmlschemastypes.h", "vtklibxml2/include/libxml/xmlstring.h", "vtklibxml2/include/libxml/xmlunicode.h", "vtklibxml2/include/libxml/xmlwriter.h", "vtklibxml2/include/libxml/xpath.h", "vtklibxml2/include/libxml/xpathInternals.h", "vtklibxml2/include/libxml/xpointer.h"], "licenses": []}, "VTK::zlib": {"library_name": "vtkzlib", "description": "", "enabled": true, "implementable": false, "third_party": true, "wrap_exclude": false, "kit": null, "depends": [], "optional_depends": [], "private_depends": [], "implements": [], "headers": ["vtkzlib/zconf.h", "vtkzlib/zlib.h"], "licenses": []}, "VTK::IOImport": {"library_name": "vtkIOImport", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": null, "depends": ["VTK::CommonCore", "VTK::CommonExecutionModel", "VTK::CommonMisc", "VTK::RenderingCore", "VTK::vtksys"], "optional_depends": [], "private_depends": ["VTK::CommonDataModel", "VTK::CommonTransforms", "VTK::FiltersCore", "VTK::FiltersSources", "VTK::ImagingCore", "VTK::IOGeometry", "VTK::IOImage"], "implements": [], "headers": ["vtk3DS.h", "vtk3DSImporter.h", "vtkGLTFImporter.h", "vtkImporter.h", "vtkVRMLImporter.h", "vtkOBJImporter.h", "vtkIOImportModule.h"], "licenses": []}, "VTK::IOIOSS": {"library_name": "vtkIOIOSS", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": null, "depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::CommonExecutionModel", "VTK::IOCore", "VTK::ParallelCore"], "optional_depends": ["VTK::ParallelMPI", "VTK::mpi"], "private_depends": ["VTK::FiltersCore", "VTK::FiltersExtraction", "VTK::fmt", "VTK::ioss"], "implements": [], "headers": ["vtkIOSSReader.h", "vtkIOSSWriter.h", "vtkIOIOSSModule.h"], "licenses": []}, "VTK::fmt": {"library_name": "vtkfmt", "description": "", "enabled": true, "implementable": false, "third_party": true, "wrap_exclude": false, "kit": null, "depends": [], "optional_depends": [], "private_depends": [], "implements": [], "headers": ["vtkfmt/vtkfmt/args.h", "vtkfmt/vtkfmt/chrono.h", "vtkfmt/vtkfmt/color.h", "vtkfmt/vtkfmt/compile.h", "vtkfmt/vtkfmt/core.h", "vtkfmt/vtkfmt/format.h", "vtkfmt/vtkfmt/format-inl.h", "vtkfmt/vtkfmt/os.h", "vtkfmt/vtkfmt/ostream.h", "vtkfmt/vtkfmt/printf.h", "vtkfmt/vtkfmt/ranges.h", "vtkfmt/vtkfmt/std.h", "vtkfmt/vtkfmt/xchar.h"], "licenses": []}, "VTK::ioss": {"library_name": "vtkioss", "description": "", "enabled": true, "implementable": false, "third_party": true, "wrap_exclude": false, "kit": null, "depends": ["VTK::cgns"], "optional_depends": ["VTK::mpi"], "private_depends": ["VTK::exodusII", "VTK::fmt", "VTK::zlib"], "implements": [], "headers": [], "licenses": []}, "VTK::cgns": {"library_name": "vtkcgns", "description": "", "enabled": true, "implementable": false, "third_party": true, "wrap_exclude": false, "kit": null, "depends": ["VTK::hdf5"], "optional_depends": [], "private_depends": [], "implements": [], "headers": [], "licenses": []}, "VTK::exodusII": {"library_name": "vtkexodusII", "description": "", "enabled": true, "implementable": false, "third_party": true, "wrap_exclude": false, "kit": null, "depends": ["VTK::hdf5", "VTK::netcdf"], "optional_depends": ["VTK::mpi"], "private_depends": [], "implements": [], "headers": ["vtkexodusII/include/exodusII.h", "vtkexodusII/include/exodusII_int.h", "vtkexodusII/include/vtk_exodusII_mangle.h", "vtkexodusII/include/exodusII_cfg.h", "vtkexodusII/include/exodus_config.h"], "licenses": []}, "VTK::IOFLUENTCFF": {"library_name": "vtkIOFLUENTCFF", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::IO", "depends": ["VTK::CommonCore", "VTK::CommonExecutionModel"], "optional_depends": [], "private_depends": ["VTK::CommonMisc", "VTK::hdf5"], "implements": [], "headers": ["vtkFLUENTCFFReader.h", "vtkIOFLUENTCFFModule.h"], "licenses": []}, "VTK::IOVideo": {"library_name": "vtkIOVideo", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::IO", "depends": ["VTK::CommonExecutionModel"], "optional_depends": [], "private_depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::CommonSystem", "VTK::vtksys"], "implements": [], "headers": ["vtkIOVideoConfigure.h", "vtkVideoSource.h", "vtkIOVideoModule.h"], "licenses": []}, "VTK::IOMovie": {"library_name": "vtkIOMovie", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::IO", "depends": ["VTK::CommonExecutionModel"], "optional_depends": [], "private_depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::CommonMisc", "VTK::CommonSystem"], "implements": [], "headers": ["vtkIOMovieConfigure.h", "vtkGenericMovieWriter.h", "vtkIOMovieModule.h"], "licenses": []}, "VTK::IOExportPDF": {"library_name": "vtkIOExportPDF", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": null, "depends": ["VTK::IOExport", "VTK::RenderingContext2D"], "optional_depends": [], "private_depends": ["VTK::CommonCore", "VTK::ImagingCore", "VTK::libharu"], "implements": ["VTK::IOExport"], "headers": ["vtkPDFContextDevice2D.h", "vtkPDFExporter.h", "vtkIOExportPDFModule.h"], "licenses": []}, "VTK::libharu": {"library_name": "vtklibharu", "description": "", "enabled": true, "implementable": false, "third_party": true, "wrap_exclude": false, "kit": null, "depends": [], "optional_depends": [], "private_depends": ["VTK::png", "VTK::zlib"], "implements": [], "headers": [], "licenses": []}, "VTK::IOExportGL2PS": {"library_name": "vtkIOExportGL2PS", "description": "", "enabled": true, "implementable": true, "third_party": false, "wrap_exclude": false, "kit": null, "depends": ["VTK::IOExport", "VTK::RenderingGL2PSOpenGL2"], "optional_depends": [], "private_depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::ImagingCore", "VTK::RenderingCore", "VTK::gl2ps"], "implements": ["VTK::IOExportGL2PS"], "headers": ["vtkGL2PSExporter.h", "vtkOpenGLGL2PSExporter.h", "vtkIOExportGL2PSModule.h"], "licenses": []}, "VTK::RenderingGL2PSOpenGL2": {"library_name": "vtkRenderingGL2PSOpenGL2", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": null, "depends": ["VTK::RenderingOpenGL2"], "optional_depends": [], "private_depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::CommonMath", "VTK::RenderingCore", "VTK::RenderingOpenGL2", "VTK::gl2ps", "VTK::opengl"], "implements": ["VTK::RenderingOpenGL2"], "headers": ["vtkOpenGLGL2PSHelperImpl.h", "vtkRenderingGL2PSOpenGL2Module.h"], "licenses": []}, "VTK::gl2ps": {"library_name": "vtkgl2ps", "description": "", "enabled": true, "implementable": false, "third_party": true, "wrap_exclude": false, "kit": null, "depends": [], "optional_depends": [], "private_depends": ["VTK::opengl", "VTK::png", "VTK::zlib"], "implements": [], "headers": ["vtkgl2ps/gl2ps.h", "vtkgl2ps/vtk_gl2ps_mangle.h"], "licenses": []}, "VTK::png": {"library_name": "vtkpng", "description": "", "enabled": true, "implementable": false, "third_party": true, "wrap_exclude": false, "kit": null, "depends": ["VTK::zlib"], "optional_depends": [], "private_depends": [], "implements": [], "headers": ["vtkpng/png.h", "vtkpng/pngconf.h", "vtkpng/pnglibconf.h", "vtkpng/vtk_png_mangle.h"], "licenses": []}, "VTK::IOExport": {"library_name": "vtkIOExport", "description": "", "enabled": true, "implementable": true, "third_party": false, "wrap_exclude": false, "kit": null, "depends": ["VTK::CommonCore", "VTK::IOCore", "VTK::IOImage", "VTK::IOXML", "VTK::RenderingContext2D", "VTK::RenderingCore", "VTK::RenderingFreeType", "VTK::RenderingVtkJS"], "optional_depends": [], "private_depends": ["VTK::CommonDataModel", "VTK::CommonMath", "VTK::CommonTransforms", "VTK::DomainsChemistry", "VTK::FiltersCore", "VTK::FiltersGeometry", "VTK::IOImage", "VTK::IOGeometry", "VTK::ImagingCore", "VTK::nlohmannjson", "VTK::libharu", "VTK::utf8"], "implements": [], "headers": ["vtkExporter.h", "vtkGLTFExporter.h", "vtkIVExporter.h", "vtkJSONDataSetWriter.h", "vtkJSONRenderWindowExporter.h", "vtkJSONSceneExporter.h", "vtkOBJExporter.h", "vtkOOGLExporter.h", "vtkPOVExporter.h", "vtkRIBExporter.h", "vtkRIBLight.h", "vtkRIBProperty.h", "vtkSVGContextDevice2D.h", "vtkSVGExporter.h", "vtkSingleVTPExporter.h", "vtkVRMLExporter.h", "vtkX3D.h", "vtkX3DExporter.h", "vtkX3DExporterFIWriter.h", "vtkX3DExporterWriter.h", "vtkX3DExporterXMLWriter.h", "vtkIOExportModule.h"], "licenses": []}, "VTK::RenderingVtkJS": {"library_name": "vtkRenderingVtkJS", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": null, "depends": ["VTK::CommonCore", "VTK::RenderingSceneGraph", "VTK::jsoncpp"], "optional_depends": [], "private_depends": ["VTK::CommonDataModel", "VTK::CommonExecutionModel", "VTK::RenderingCore"], "implements": [], "headers": ["vtkVtkJSSceneGraphSerializer.h", "vtkVtkJSViewNodeFactory.h", "vtkRenderingVtkJSModule.h"], "licenses": []}, "VTK::nlohmannjson": {"library_name": "vtknlohmannjson", "description": "", "enabled": true, "implementable": false, "third_party": true, "wrap_exclude": false, "kit": null, "depends": [], "optional_depends": [], "private_depends": [], "implements": [], "headers": ["vtknlohmannjson/include/vtknlohmann/adl_serializer.hpp", "vtknlohmannjson/include/vtknlohmann/byte_container_with_subtype.hpp", "vtknlohmannjson/include/vtknlohmann/json.hpp", "vtknlohmannjson/include/vtknlohmann/json_fwd.hpp", "vtknlohmannjson/include/vtknlohmann/ordered_map.hpp", "vtknlohmannjson/include/vtknlohmann/detail/conversions/from_json.hpp", "vtknlohmannjson/include/vtknlohmann/detail/conversions/to_chars.hpp", "vtknlohmannjson/include/vtknlohmann/detail/conversions/to_json.hpp", "vtknlohmannjson/include/vtknlohmann/detail/exceptions.hpp", "vtknlohmannjson/include/vtknlohmann/detail/hash.hpp", "vtknlohmannjson/include/vtknlohmann/detail/input/binary_reader.hpp", "vtknlohmannjson/include/vtknlohmann/detail/input/input_adapters.hpp", "vtknlohmannjson/include/vtknlohmann/detail/input/json_sax.hpp", "vtknlohmannjson/include/vtknlohmann/detail/input/lexer.hpp", "vtknlohmannjson/include/vtknlohmann/detail/input/parser.hpp", "vtknlohmannjson/include/vtknlohmann/detail/input/position_t.hpp", "vtknlohmannjson/include/vtknlohmann/detail/iterators/internal_iterator.hpp", "vtknlohmannjson/include/vtknlohmann/detail/iterators/iter_impl.hpp", "vtknlohmannjson/include/vtknlohmann/detail/iterators/iteration_proxy.hpp", "vtknlohmannjson/include/vtknlohmann/detail/iterators/iterator_traits.hpp", "vtknlohmannjson/include/vtknlohmann/detail/iterators/json_reverse_iterator.hpp", "vtknlohmannjson/include/vtknlohmann/detail/iterators/primitive_iterator.hpp", "vtknlohmannjson/include/vtknlohmann/detail/json_pointer.hpp", "vtknlohmannjson/include/vtknlohmann/detail/json_ref.hpp", "vtknlohmannjson/include/vtknlohmann/detail/macro_scope.hpp", "vtknlohmannjson/include/vtknlohmann/detail/macro_unscope.hpp", "vtknlohmannjson/include/vtknlohmann/detail/meta/call_std/begin.hpp", "vtknlohmannjson/include/vtknlohmann/detail/meta/call_std/end.hpp", "vtknlohmannjson/include/vtknlohmann/detail/meta/cpp_future.hpp", "vtknlohmannjson/include/vtknlohmann/detail/meta/detected.hpp", "vtknlohmannjson/include/vtknlohmann/detail/meta/identity_tag.hpp", "vtknlohmannjson/include/vtknlohmann/detail/meta/is_sax.hpp", "vtknlohmannjson/include/vtknlohmann/detail/meta/type_traits.hpp", "vtknlohmannjson/include/vtknlohmann/detail/meta/void_t.hpp", "vtknlohmannjson/include/vtknlohmann/detail/output/binary_writer.hpp", "vtknlohmannjson/include/vtknlohmann/detail/output/output_adapters.hpp", "vtknlohmannjson/include/vtknlohmann/detail/output/serializer.hpp", "vtknlohmannjson/include/vtknlohmann/detail/string_escape.hpp", "vtknlohmannjson/include/vtknlohmann/detail/value_t.hpp", "vtknlohmannjson/include/vtknlohmann/thirdparty/hedley/hedley.hpp", "vtknlohmannjson/include/vtknlohmann/thirdparty/hedley/hedley_undef.hpp"], "licenses": []}, "VTK::RenderingSceneGraph": {"library_name": "vtkRenderingSceneGraph", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Rendering", "depends": ["VTK::CommonCore"], "optional_depends": [], "private_depends": ["VTK::CommonDataModel", "VTK::CommonMath", "VTK::RenderingCore"], "implements": [], "headers": ["vtkActorNode.h", "vtkCameraNode.h", "vtkLightNode.h", "vtkMapperNode.h", "vtkPolyDataMapperNode.h", "vtkRendererNode.h", "vtkViewNode.h", "vtkViewNodeFactory.h", "vtkVolumeMapperNode.h", "vtkVolumeNode.h", "vtkWindowNode.h", "vtkRenderingSceneGraphModule.h"], "licenses": []}, "VTK::IOExodus": {"library_name": "vtkIOExodus", "description": "", "enabled": true, "implementable": true, "third_party": false, "wrap_exclude": false, "kit": "VTK::IO", "depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::CommonExecutionModel", "VTK::IOCore", "VTK::IOXMLParser", "VTK::exodusII"], "optional_depends": [], "private_depends": ["VTK::FiltersCore", "VTK::vtksys"], "implements": [], "headers": ["vtkCPExodusIIElementBlock.h", "vtkCPExodusIIInSituReader.h", "vtkExodusIICache.h", "vtkExodusIIReader.h", "vtkExodusIIReaderParser.h", "vtkExodusIIWriter.h", "vtkModelMetadata.h", "vtkCPExodusIINodalCoordinatesTemplate.h", "vtkCPExodusIIResultsArrayTemplate.h", "vtkIOExodusModule.h"], "licenses": []}, "VTK::IOEnSight": {"library_name": "vtkIOEnSight", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::IO", "depends": ["VTK::CommonExecutionModel"], "optional_depends": [], "private_depends": ["VTK::FiltersGeneral", "VTK::CommonCore", "VTK::CommonDataModel"], "implements": [], "headers": ["vtkEnSight6BinaryReader.h", "vtkEnSight6Reader.h", "vtkEnSightGoldBinaryReader.h", "vtkEnSightGoldReader.h", "vtkEnSightMasterServerReader.h", "vtkEnSightReader.h", "vtkGenericEnSightReader.h", "vtkIOEnSightModule.h"], "licenses": []}, "VTK::IOCityGML": {"library_name": "vtkIOCityGML", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::IO", "depends": ["VTK::CommonExecutionModel"], "optional_depends": [], "private_depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::FiltersGeneral", "VTK::FiltersModeling", "VTK::pugixml", "VTK::vtksys"], "implements": [], "headers": ["vtkCityGMLReader.h", "vtkIOCityGMLModule.h"], "licenses": []}, "VTK::pugixml": {"library_name": "vtkpugixml", "description": "", "enabled": true, "implementable": false, "third_party": true, "wrap_exclude": false, "kit": null, "depends": [], "optional_depends": [], "private_depends": [], "implements": [], "headers": ["vtkpugixml/src/pugixml.hpp", "vtkpugixml/pugiconfig.hpp", "vtkpugixml/src/vtk_pugixml_mangle.h"], "licenses": []}, "VTK::IOChemistry": {"library_name": "vtkIOChemistry", "description": "", "enabled": true, "implementable": true, "third_party": false, "wrap_exclude": false, "kit": null, "depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::CommonExecutionModel", "VTK::IOCore"], "optional_depends": [], "private_depends": ["VTK::CommonSystem", "VTK::DomainsChemistry", "VTK::RenderingCore", "VTK::vtksys", "VTK::zlib"], "implements": [], "headers": ["vtkCMLMoleculeReader.h", "vtkGaussianCubeReader.h", "vtkGaussianCubeReader2.h", "vtkMoleculeReaderBase.h", "vtkPDBReader.h", "vtkVASPAnimationReader.h", "vtkVASPTessellationReader.h", "vtkXYZMolReader.h", "vtkXYZMolReader2.h", "vtkIOChemistryModule.h"], "licenses": []}, "VTK::IOCesium3DTiles": {"library_name": "vtkIOCesium3DTiles", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": null, "depends": ["VTK::IOCore"], "optional_depends": [], "private_depends": ["VTK::CommonCore", "VTK::CommonTransforms", "VTK::CommonSystem", "VTK::IOImage", "VTK::IOGeometry", "VTK::IOXML", "VTK::FiltersGeneral", "VTK::FiltersGeometry", "VTK::FiltersExtraction", "VTK::RenderingCore", "VTK::vtksys", "VTK::libproj", "VTK::nlohmannjson"], "implements": [], "headers": ["vtkCesium3DTilesWriter.h", "vtkCesiumPointCloudWriter.h", "vtkIOCesium3DTilesModule.h"], "licenses": []}, "VTK::IOGeometry": {"library_name": "vtkIOGeometry", "description": "", "enabled": true, "implementable": true, "third_party": false, "wrap_exclude": false, "kit": "VTK::IO", "depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::CommonExecutionModel", "VTK::IOCore", "VTK::IOLegacy", "VTK::nlohmannjson"], "optional_depends": [], "private_depends": ["VTK::CommonMisc", "VTK::CommonSystem", "VTK::CommonTransforms", "VTK::FiltersGeneral", "VTK::FiltersHybrid", "VTK::FiltersVerdict", "VTK::ImagingCore", "VTK::IOImage", "VTK::RenderingCore", "VTK::vtksys", "VTK::zlib"], "implements": [], "headers": ["vtkAVSucdReader.h", "vtkBYUReader.h", "vtkBYUWriter.h", "vtkChacoReader.h", "vtkFacetWriter.h", "vtkFLUENTReader.h", "vtkGAMBITReader.h", "vtkGLTFDocumentLoader.h", "vtkGLTFReader.h", "vtkGLTFWriter.h", "vtkHoudiniPolyDataWriter.h", "vtkIVWriter.h", "vtkMCubesReader.h", "vtkMCubesWriter.h", "vtkMFIXReader.h", "vtkOBJReader.h", "vtkOBJWriter.h", "vtkOpenFOAMReader.h", "vtkParticleReader.h", "vtkProStarReader.h", "vtkPTSReader.h", "vtkSTLReader.h", "vtkSTLWriter.h", "vtkTecplotReader.h", "vtkWindBladeReader.h", "vtkIOGeometryModule.h"], "licenses": []}, "VTK::IOCellGrid": {"library_name": "vtkIOCellGrid", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::IO", "depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::CommonExecutionModel", "VTK::IOCore", "VTK::FiltersCellGrid"], "optional_depends": [], "private_depends": ["VTK::CommonMisc", "VTK::CommonSystem", "VTK::CommonTransforms", "VTK::nlohmannjson", "VTK::vtksys"], "implements": [], "headers": ["vtkCellGridReader.h", "vtkIOCellGridModule.h"], "licenses": []}, "VTK::IOCONVERGECFD": {"library_name": "vtkIOCONVERGECFD", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": null, "depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::CommonExecutionModel"], "optional_depends": [], "private_depends": ["VTK::CommonSystem", "VTK::hdf5", "VTK::IOHDF", "VTK::vtksys"], "implements": [], "headers": ["vtkCONVERGECFDReader.h", "vtkIOCONVERGECFDModule.h"], "licenses": []}, "VTK::IOHDF": {"library_name": "vtkIOHDF", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::IO", "depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::CommonExecutionModel", "VTK::FiltersCore"], "optional_depends": [], "private_depends": ["VTK::CommonSystem", "VTK::hdf5", "VTK::IOCore", "VTK::vtksys"], "implements": [], "headers": ["vtkHDFReader.h", "vtkIOHDFModule.h"], "licenses": []}, "VTK::IOCGNSReader": {"library_name": "vtkIOCGNSReader", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Parallel", "depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::CommonExecutionModel", "VTK::ParallelCore"], "optional_depends": [], "private_depends": ["VTK::cgns", "VTK::FiltersExtraction", "VTK::ParallelCore", "VTK::hdf5", "VTK::vtksys"], "implements": [], "headers": ["vtkCGNSFileSeriesReader.h", "vtkCGNSReader.h", "vtkIOCGNSReaderModule.h"], "licenses": []}, "VTK::IOAsynchronous": {"library_name": "vtkIOAsynchronous", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": null, "depends": ["VTK::CommonCore", "VTK::CommonExecutionModel", "VTK::IOCore", "VTK::IOImage", "VTK::IOXML"], "optional_depends": [], "private_depends": ["VTK::CommonDataModel", "VTK::CommonMath", "VTK::CommonMisc", "VTK::CommonSystem", "VTK::ParallelCore"], "implements": [], "headers": ["vtkThreadedImageWriter.h", "vtkIOAsynchronousModule.h"], "licenses": []}, "VTK::IOAMR": {"library_name": "vtkIOAMR", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Parallel", "depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::CommonExecutionModel"], "optional_depends": [], "private_depends": ["VTK::CommonSystem", "VTK::FiltersAMR", "VTK::ParallelCore", "VTK::hdf5", "VTK::vtksys"], "implements": [], "headers": ["vtkAMRBaseParticlesReader.h", "vtkAMRBaseReader.h", "vtkAMRDataSetCache.h", "vtkAMREnzoParticlesReader.h", "vtkAMREnzoReader.h", "vtkAMReXGridReader.h", "vtkAMReXParticlesReader.h", "vtkAMRFlashParticlesReader.h", "vtkAMRFlashReader.h", "vtkAMRVelodyneReader.h", "vtkIOAMRModule.h"], "licenses": []}, "VTK::InteractionImage": {"library_name": "vtkInteractionImage", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Interaction", "depends": ["VTK::CommonCore", "VTK::RenderingCore"], "optional_depends": [], "private_depends": ["VTK::CommonDataModel", "VTK::CommonExecutionModel", "VTK::ImagingColor", "VTK::ImagingCore", "VTK::InteractionStyle", "VTK::InteractionWidgets"], "implements": [], "headers": ["vtkImageViewer.h", "vtkImageViewer2.h", "vtkResliceImageViewer.h", "vtkResliceImageViewerMeasurements.h", "vtkInteractionImageModule.h"], "licenses": []}, "VTK::ImagingStencil": {"library_name": "vtkImagingStencil", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Imaging", "depends": ["VTK::CommonExecutionModel", "VTK::ImagingCore"], "optional_depends": [], "private_depends": ["VTK::CommonComputationalGeometry", "VTK::CommonCore", "VTK::CommonDataModel"], "implements": [], "headers": ["vtkImageStencil.h", "vtkImageStencilToImage.h", "vtkImageToImageStencil.h", "vtkImplicitFunctionToImageStencil.h", "vtkLassoStencilSource.h", "vtkPolyDataToImageStencil.h", "vtkROIStencilSource.h", "vtkImagingStencilModule.h"], "licenses": []}, "VTK::ImagingStatistics": {"library_name": "vtkImagingStatistics", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Imaging", "depends": ["VTK::CommonExecutionModel"], "optional_depends": [], "private_depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::ImagingCore"], "implements": [], "headers": ["vtkImageAccumulate.h", "vtkImageHistogram.h", "vtkImageHistogramStatistics.h", "vtkImagingStatisticsModule.h"], "licenses": []}, "VTK::ImagingMorphological": {"library_name": "vtkImagingMorphological", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Imaging", "depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::CommonExecutionModel", "VTK::ImagingCore", "VTK::ImagingGeneral"], "optional_depends": [], "private_depends": ["VTK::ImagingSources"], "implements": [], "headers": ["vtkImageConnectivityFilter.h", "vtkImageConnector.h", "vtkImageContinuousDilate3D.h", "vtkImageContinuousErode3D.h", "vtkImageDilateErode3D.h", "vtkImageIslandRemoval2D.h", "vtkImageNonMaximumSuppression.h", "vtkImageOpenClose3D.h", "vtkImageSeedConnectivity.h", "vtkImageSkeleton2D.h", "vtkImageThresholdConnectivity.h", "vtkImagingMorphologicalModule.h"], "licenses": []}, "VTK::ImagingMath": {"library_name": "vtkImagingMath", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Imaging", "depends": ["VTK::CommonExecutionModel"], "optional_depends": [], "private_depends": ["VTK::CommonCore", "VTK::CommonDataModel"], "implements": [], "headers": ["vtkImageDivergence.h", "vtkImageDotProduct.h", "vtkImageLogarithmicScale.h", "vtkImageLogic.h", "vtkImageMagnitude.h", "vtkImageMaskBits.h", "vtkImageMathematics.h", "vtkImageWeightedSum.h", "vtkImagingMathModule.h"], "licenses": []}, "VTK::ImagingFourier": {"library_name": "vtkImagingFourier", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Imaging", "depends": ["VTK::CommonCore", "VTK::CommonExecutionModel", "VTK::ImagingCore"], "optional_depends": [], "private_depends": ["VTK::CommonDataModel", "VTK::vtksys"], "implements": [], "headers": ["vtkImageButterworthHighPass.h", "vtkImageButterworthLowPass.h", "vtkImageFFT.h", "vtkImageFourierCenter.h", "vtkImageFourierFilter.h", "vtkImageIdealHighPass.h", "vtkImageIdealLowPass.h", "vtkImageRFFT.h", "vtkImagingFourierModule.h"], "licenses": []}, "VTK::IOSQL": {"library_name": "vtkIOSQL", "description": "", "enabled": true, "implementable": true, "third_party": false, "wrap_exclude": false, "kit": "VTK::IO", "depends": ["VTK::CommonCore", "VTK::CommonExecutionModel", "VTK::IOCore"], "optional_depends": [], "private_depends": ["VTK::sqlite", "VTK::vtksys"], "implements": [], "headers": ["vtkDatabaseToTableReader.h", "vtkRowQuery.h", "vtkRowQueryToTable.h", "vtkSQLDatabase.h", "vtkSQLDatabaseSchema.h", "vtkSQLDatabaseTableSource.h", "vtkSQLiteDatabase.h", "vtkSQLiteQuery.h", "vtkSQLiteToTableReader.h", "vtkSQLQuery.h", "vtkTableToDatabaseWriter.h", "vtkTableToSQLiteWriter.h", "vtkIOSQLModule.h"], "licenses": []}, "VTK::sqlite": {"library_name": "vtksqlite", "description": "", "enabled": true, "implementable": false, "third_party": true, "wrap_exclude": false, "kit": null, "depends": [], "optional_depends": [], "private_depends": [], "implements": [], "headers": ["vtksqlite/sqlite3.h", "vtksqlite/vtk_sqlite_mangle.h", "vtksqlite/vtksqlite_export.h"], "licenses": []}, "VTK::GeovisCore": {"library_name": "vtkGeovisCore", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": null, "depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::CommonExecutionModel", "VTK::CommonTransforms", "VTK::InfovisCore", "VTK::InteractionStyle", "VTK::InteractionWidgets", "VTK::RenderingCore", "VTK::ViewsCore", "VTK::libproj"], "optional_depends": [], "private_depends": ["VTK::CommonSystem", "VTK::FiltersCore", "VTK::FiltersGeneral", "VTK::IOImage", "VTK::IOXML", "VTK::ImagingCore", "VTK::ImagingSources", "VTK::InfovisLayout"], "implements": [], "headers": ["vtkGeoProjection.h", "vtkGeoTransform.h", "vtkGeovisCoreModule.h"], "licenses": []}, "VTK::InfovisLayout": {"library_name": "vtkInfovisLayout", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": null, "depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::CommonExecutionModel"], "optional_depends": ["VTK::InfovisBoostGraphAlgorithms"], "private_depends": ["VTK::CommonComputationalGeometry", "VTK::CommonSystem", "VTK::CommonTransforms", "VTK::FiltersCore", "VTK::FiltersGeneral", "VTK::FiltersModeling", "VTK::FiltersSources", "VTK::ImagingHybrid", "VTK::InfovisCore"], "implements": [], "headers": ["vtkArcParallelEdgeStrategy.h", "vtkAreaLayout.h", "vtkAreaLayoutStrategy.h", "vtkAssignCoordinates.h", "vtkAssignCoordinatesLayoutStrategy.h", "vtkAttributeClustering2DLayoutStrategy.h", "vtkBoxLayoutStrategy.h", "vtkCirclePackFrontChainLayoutStrategy.h", "vtkCirclePackLayout.h", "vtkCirclePackLayoutStrategy.h", "vtkCirclePackToPolyData.h", "vtkCircularLayoutStrategy.h", "vtkClustering2DLayoutStrategy.h", "vtkCommunity2DLayoutStrategy.h", "vtkConeLayoutStrategy.h", "vtkConstrained2DLayoutStrategy.h", "vtkCosmicTreeLayoutStrategy.h", "vtkEdgeLayout.h", "vtkEdgeLayoutStrategy.h", "vtkFast2DLayoutStrategy.h", "vtkForceDirectedLayoutStrategy.h", "vtkGeoEdgeStrategy.h", "vtkGeoMath.h", "vtkGraphLayout.h", "vtkGraphLayoutStrategy.h", "vtkIncrementalForceLayout.h", "vtkKCoreLayout.h", "vtkPassThroughEdgeStrategy.h", "vtkPassThroughLayoutStrategy.h", "vtkPerturbCoincidentVertices.h", "vtkRandomLayoutStrategy.h", "vtkSimple2DLayoutStrategy.h", "vtkSimple3DCirclesStrategy.h", "vtkSliceAndDiceLayoutStrategy.h", "vtkSpanTreeLayoutStrategy.h", "vtkSplineGraphEdges.h", "vtkSquarifyLayoutStrategy.h", "vtkStackedTreeLayoutStrategy.h", "vtkTreeLayoutStrategy.h", "vtkTreeMapLayout.h", "vtkTreeMapLayoutStrategy.h", "vtkTreeMapToPolyData.h", "vtkTreeOrbitLayoutStrategy.h", "vtkTreeRingToPolyData.h", "vtkInfovisLayoutModule.h"], "licenses": []}, "VTK::ViewsCore": {"library_name": "vtkViewsCore", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Views", "depends": ["VTK::CommonCore", "VTK::CommonExecutionModel", "VTK::InteractionWidgets"], "optional_depends": [], "private_depends": ["VTK::CommonDataModel", "VTK::FiltersGeneral", "VTK::RenderingCore", "VTK::RenderingUI"], "implements": [], "headers": ["vtkConvertSelectionDomain.h", "vtkDataRepresentation.h", "vtkEmptyRepresentation.h", "vtkRenderViewBase.h", "vtkView.h", "vtkViewTheme.h", "vtkViewsCoreModule.h"], "licenses": []}, "VTK::InteractionWidgets": {"library_name": "vtkInteractionWidgets", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Interaction", "depends": ["VTK::CommonCore", "VTK::CommonExecutionModel", "VTK::FiltersGeneral", "VTK::FiltersSources", "VTK::RenderingCore", "VTK::RenderingContext2D"], "optional_depends": [], "private_depends": ["VTK::CommonComputationalGeometry", "VTK::CommonDataModel", "VTK::CommonMath", "VTK::CommonSystem", "VTK::CommonTransforms", "VTK::FiltersCore", "VTK::FiltersHybrid", "VTK::FiltersModeling", "VTK::FiltersTexture", "VTK::ImagingColor", "VTK::ImagingCore", "VTK::ImagingGeneral", "VTK::ImagingHybrid", "VTK::InteractionStyle", "VTK::RenderingAnnotation", "VTK::RenderingFreeType", "VTK::RenderingVolume", "VTK::RenderingOpenGL2"], "implements": [], "headers": ["vtk3DCursorRepresentation.h", "vtk3DCursorWidget.h", "vtk3DWidget.h", "vtkAbstractPolygonalHandleRepresentation3D.h", "vtkAbstractSplineRepresentation.h", "vtkAbstractWidget.h", "vtkAffineRepresentation.h", "vtkAffineRepresentation2D.h", "vtkAffineWidget.h", "vtkAngleRepresentation.h", "vtkAngleRepresentation2D.h", "vtkAngleRepresentation3D.h", "vtkAngleWidget.h", "vtkAxesTransformRepresentation.h", "vtkAxesTransformWidget.h", "vtkBalloonRepresentation.h", "vtkBalloonWidget.h", "vtkBezierContourLineInterpolator.h", "vtkBiDimensionalRepresentation.h", "vtkBiDimensionalRepresentation2D.h", "vtkBiDimensionalWidget.h", "vtkBorderRepresentation.h", "vtkBorderWidget.h", "vtkBoundedPlanePointPlacer.h", "vtkBoxRepresentation.h", "vtkBoxWidget.h", "vtkBoxWidget2.h", "vtkBrokenLineWidget.h", "vtkButtonRepresentation.h", "vtkButtonWidget.h", "vtkCamera3DRepresentation.h", "vtkCamera3DWidget.h", "vtkCameraHandleSource.h", "vtkCameraOrientationWidget.h", "vtkCameraOrientationRepresentation.h", "vtkCameraPathRepresentation.h", "vtkCameraPathWidget.h", "vtkCameraRepresentation.h", "vtkCameraWidget.h", "vtkCaptionRepresentation.h", "vtkCaptionWidget.h", "vtkCellCentersPointPlacer.h", "vtkCenteredSliderRepresentation.h", "vtkCenteredSliderWidget.h", "vtkCheckerboardRepresentation.h", "vtkCheckerboardWidget.h", "vtkClosedSurfacePointPlacer.h", "vtkCompassRepresentation.h", "vtkCompassWidget.h", "vtkConstrainedPointHandleRepresentation.h", "vtkContinuousValueWidget.h", "vtkContinuousValueWidgetRepresentation.h", "vtkContourLineInterpolator.h", "vtkContourRepresentation.h", "vtkContourWidget.h", "vtkCoordinateFrameRepresentation.h", "vtkCoordinateFrameWidget.h", "vtkCurveRepresentation.h", "vtkDijkstraImageContourLineInterpolator.h", "vtkDisplaySizedImplicitPlaneWidget.h", "vtkDisplaySizedImplicitPlaneRepresentation.h", "vtkDistanceRepresentation.h", "vtkDistanceRepresentation2D.h", "vtkDistanceRepresentation3D.h", "vtkDistanceWidget.h", "vtkEllipsoidTensorProbeRepresentation.h", "vtkEqualizerContextItem.h", "vtkEvent.h", "vtkFinitePlaneRepresentation.h", "vtkFinitePlaneWidget.h", "vtkFixedSizeHandleRepresentation3D.h", "vtkFocalPlaneContourRepresentation.h", "vtkFocalPlanePointPlacer.h", "vtkHandleRepresentation.h", "vtkHandleWidget.h", "vtkHoverWidget.h", "vtkImageActorPointPlacer.h", "vtkImageCroppingRegionsWidget.h", "vtkImageOrthoPlanes.h", "vtkImagePlaneWidget.h", "vtkImageTracerWidget.h", "vtkImplicitCylinderRepresentation.h", "vtkImplicitCylinderWidget.h", "vtkImplicitImageRepresentation.h", "vtkImplicitPlaneRepresentation.h", "vtkImplicitPlaneWidget.h", "vtkImplicitPlaneWidget2.h", "vtkLightRepresentation.h", "vtkLightWidget.h", "vtkLinearContourLineInterpolator.h", "vtkLineRepresentation.h", "vtkLineWidget.h", "vtkLineWidget2.h", "vtkLogoRepresentation.h", "vtkLogoWidget.h", "vtkMagnifierRepresentation.h", "vtkMagnifierWidget.h", "vtkMeasurementCubeHandleRepresentation3D.h", "vtkOrientationMarkerWidget.h", "vtkOrientationRepresentation.h", "vtkOrientationWidget.h", "vtkOrientedGlyphContourRepresentation.h", "vtkOrientedGlyphFocalPlaneContourRepresentation.h", "vtkOrientedPolygonalHandleRepresentation3D.h", "vtkParallelopipedRepresentation.h", "vtkParallelopipedWidget.h", "vtkPlaneWidget.h", "vtkPlaybackRepresentation.h", "vtkPlaybackWidget.h", "vtkPointCloudRepresentation.h", "vtkPointCloudWidget.h", "vtkPointHandleRepresentation2D.h", "vtkPointHandleRepresentation3D.h", "vtkPointPlacer.h", "vtkPointWidget.h", "vtkPolyDataContourLineInterpolator.h", "vtkPolyDataPointPlacer.h", "vtkPolyDataSourceWidget.h", "vtkPolygonalHandleRepresentation3D.h", "vtkPolygonalSurfaceContourLineInterpolator.h", "vtkPolygonalSurfacePointPlacer.h", "vtkPolyLineRepresentation.h", "vtkPolyLineWidget.h", "vtkProgressBarRepresentation.h", "vtkProgressBarWidget.h", "vtkProp3DButtonRepresentation.h", "vtkRectilinearWipeRepresentation.h", "vtkRectilinearWipeWidget.h", "vtkResliceCursor.h", "vtkResliceCursorActor.h", "vtkResliceCursorLineRepresentation.h", "vtkResliceCursorPicker.h", "vtkResliceCursorPolyDataAlgorithm.h", "vtkResliceCursorRepresentation.h", "vtkResliceCursorThickLineRepresentation.h", "vtkResliceCursorWidget.h", "vtkScalarBarRepresentation.h", "vtkScalarBarWidget.h", "vtkSeedRepresentation.h", "vtkSeedWidget.h", "vtkSliderRepresentation.h", "vtkSliderRepresentation2D.h", "vtkSliderRepresentation3D.h", "vtkSliderWidget.h", "vtkSphereHandleRepresentation.h", "vtkSphereRepresentation.h", "vtkSphereWidget.h", "vtkSphereWidget2.h", "vtkSplineRepresentation.h", "vtkSplineWidget.h", "vtkSplineWidget2.h", "vtkTensorProbeRepresentation.h", "vtkTensorProbeWidget.h", "vtkTensorRepresentation.h", "vtkTensorWidget.h", "vtkTerrainContourLineInterpolator.h", "vtkTerrainDataPointPlacer.h", "vtkTextRepresentation.h", "vtkTexturedButtonRepresentation.h", "vtkTexturedButtonRepresentation2D.h", "vtkTextWidget.h", "vtkWidgetCallbackMapper.h", "vtkWidgetEvent.h", "vtkWidgetEventTranslator.h", "vtkWidgetRepresentation.h", "vtkWidgetSet.h", "vtkXYPlotWidget.h", "vtkInteractionWidgetsModule.h"], "licenses": []}, "VTK::RenderingVolume": {"library_name": "vtkRenderingVolume", "description": "", "enabled": true, "implementable": true, "third_party": false, "wrap_exclude": false, "kit": "VTK::Rendering", "depends": ["VTK::CommonCore", "VTK::CommonExecutionModel", "VTK::RenderingCore"], "optional_depends": [], "private_depends": ["VTK::CommonDataModel", "VTK::CommonMath", "VTK::CommonMisc", "VTK::CommonSystem", "VTK::CommonTransforms", "VTK::ImagingCore"], "implements": [], "headers": ["vtkBlockSortHelper.h", "vtkDirectionEncoder.h", "vtkEncodedGradientEstimator.h", "vtkEncodedGradientShader.h", "vtkFiniteDifferenceGradientEstimator.h", "vtkFixedPointRayCastImage.h", "vtkFixedPointVolumeRayCastCompositeGOHelper.h", "vtkFixedPointVolumeRayCastCompositeGOShadeHelper.h", "vtkFixedPointVolumeRayCastCompositeHelper.h", "vtkFixedPointVolumeRayCastCompositeShadeHelper.h", "vtkFixedPointVolumeRayCastHelper.h", "vtkFixedPointVolumeRayCastMapper.h", "vtkFixedPointVolumeRayCastMIPHelper.h", "vtkGPUVolumeRayCastMapper.h", "vtkMultiVolume.h", "vtkOSPRayVolumeInterface.h", "vtkProjectedTetrahedraMapper.h", "vtkRayCastImageDisplayHelper.h", "vtkRecursiveSphereDirectionEncoder.h", "vtkSphericalDirectionEncoder.h", "vtkUnstructuredGridBunykRayCastFunction.h", "vtkUnstructuredGridHomogeneousRayIntegrator.h", "vtkUnstructuredGridLinearRayIntegrator.h", "vtkUnstructuredGridPartialPreIntegration.h", "vtkUnstructuredGridPreIntegration.h", "vtkUnstructuredGridVolumeMapper.h", "vtkUnstructuredGridVolumeRayCastFunction.h", "vtkUnstructuredGridVolumeRayCastIterator.h", "vtkUnstructuredGridVolumeRayCastMapper.h", "vtkUnstructuredGridVolumeRayIntegrator.h", "vtkUnstructuredGridVolumeZSweepMapper.h", "vtkVolumeMapper.h", "vtkVolumeOutlineSource.h", "vtkVolumePicker.h", "vtkVolumeRayCastSpaceLeapingImageFilter.h", "vtkRenderingVolumeModule.h"], "licenses": []}, "VTK::RenderingAnnotation": {"library_name": "vtkRenderingAnnotation", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Rendering", "depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::CommonExecutionModel", "VTK::RenderingCore"], "optional_depends": [], "private_depends": ["VTK::CommonMath", "VTK::CommonTransforms", "VTK::FiltersCore", "VTK::FiltersGeneral", "VTK::FiltersSources", "VTK::ImagingColor", "VTK::RenderingFreeType"], "implements": [], "headers": ["vtkAnnotatedCubeActor.h", "vtkArcPlotter.h", "vtkAxesActor.h", "vtkAxisActor.h", "vtkAxisActor2D.h", "vtkAxisFollower.h", "vtkBarChartActor.h", "vtkCaptionActor2D.h", "vtkConvexHull2D.h", "vtkCornerAnnotation.h", "vtkCubeAxesActor.h", "vtkCubeAxesActor2D.h", "vtkGraphAnnotationLayersFilter.h", "vtkLeaderActor2D.h", "vtkLegendBoxActor.h", "vtkLegendScaleActor.h", "vtkParallelCoordinatesActor.h", "vtkPieChartActor.h", "vtkPolarAxesActor.h", "vtkProp3DAxisFollower.h", "vtkScalarBarActor.h", "vtkSpiderPlotActor.h", "vtkXYPlotActor.h", "vtkRenderingAnnotationModule.h"], "licenses": []}, "VTK::ImagingHybrid": {"library_name": "vtkImagingHybrid", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": null, "depends": ["VTK::CommonCore", "VTK::CommonExecutionModel"], "optional_depends": [], "private_depends": ["VTK::CommonDataModel", "VTK::IOImage", "VTK::ImagingCore"], "implements": [], "headers": ["vtkBooleanTexture.h", "vtkCheckerboardSplatter.h", "vtkFastSplatter.h", "vtkGaussianSplatter.h", "vtkImageCursor3D.h", "vtkImageRectilinearWipe.h", "vtkImageToPoints.h", "vtkPointLoad.h", "vtkSampleFunction.h", "vtkShepardMethod.h", "vtkSliceCubes.h", "vtkSurfaceReconstructionFilter.h", "vtkTriangularTexture.h", "vtkVoxelModeller.h", "vtkImagingHybridModule.h"], "licenses": []}, "VTK::ImagingColor": {"library_name": "vtkImagingColor", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Imaging", "depends": ["VTK::CommonExecutionModel", "VTK::ImagingCore"], "optional_depends": [], "private_depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::CommonSystem"], "implements": [], "headers": ["vtkImageHSIToRGB.h", "vtkImageHSVToRGB.h", "vtkImageLuminance.h", "vtkImageMapToRGBA.h", "vtkImageMapToWindowLevelColors.h", "vtkImageQuantizeRGBToIndex.h", "vtkImageRGBToHSI.h", "vtkImageRGBToHSV.h", "vtkImageRGBToYIQ.h", "vtkImageYIQToRGB.h", "vtkImagingColorModule.h"], "licenses": []}, "VTK::InteractionStyle": {"library_name": "vtkInteractionStyle", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Interaction", "depends": ["VTK::CommonDataModel", "VTK::RenderingCore"], "optional_depends": [], "private_depends": ["VTK::CommonCore", "VTK::CommonMath", "VTK::CommonTransforms", "VTK::FiltersCore", "VTK::FiltersExtraction", "VTK::FiltersSources"], "implements": ["VTK::RenderingCore"], "headers": ["vtkInteractorStyleDrawPolygon.h", "vtkInteractorStyleFlight.h", "vtkInteractorStyleImage.h", "vtkInteractorStyleJoystickActor.h", "vtkInteractorStyleJoystickCamera.h", "vtkInteractorStyleMultiTouchCamera.h", "vtkInteractorStyleRubberBand2D.h", "vtkInteractorStyleRubberBand3D.h", "vtkInteractorStyleRubberBandPick.h", "vtkInteractorStyleRubberBandZoom.h", "vtkInteractorStyleTerrain.h", "vtkInteractorStyleTrackball.h", "vtkInteractorStyleTrackballActor.h", "vtkInteractorStyleTrackballCamera.h", "vtkInteractorStyleUnicam.h", "vtkInteractorStyleUser.h", "vtkInteractorStyleSwitch.h", "vtkParallelCoordinatesInteractorStyle.h", "vtkInteractionStyleModule.h"], "licenses": []}, "VTK::FiltersTopology": {"library_name": "vtkFiltersTopology", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Filters", "depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::CommonExecutionModel"], "optional_depends": [], "private_depends": [], "implements": [], "headers": ["vtkFiberSurface.h", "vtkFiltersTopologyModule.h"], "licenses": []}, "VTK::FiltersTensor": {"library_name": "vtkFiltersTensor", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Filters", "depends": ["VTK::CommonCore", "VTK::CommonExecutionModel"], "optional_depends": [], "private_depends": ["VTK::CommonDataModel"], "implements": [], "headers": ["vtkTensorPrincipalInvariants.h", "vtkYieldCriteria.h", "vtkFiltersTensorModule.h"], "licenses": []}, "VTK::FiltersSelection": {"library_name": "vtkFiltersSelection", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Filters", "depends": ["VTK::CommonCore", "VTK::CommonExecutionModel"], "optional_depends": [], "private_depends": ["VTK::CommonDataModel"], "implements": [], "headers": ["vtkCellDistanceSelector.h", "vtkKdTreeSelector.h", "vtkLinearSelector.h", "vtkFiltersSelectionModule.h"], "licenses": []}, "VTK::FiltersSMP": {"library_name": "vtkFiltersSMP", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Filters", "depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::CommonExecutionModel", "VTK::CommonMisc", "VTK::CommonTransforms", "VTK::FiltersCore", "VTK::FiltersGeneral"], "optional_depends": [], "private_depends": ["VTK::CommonMath", "VTK::CommonSystem"], "implements": [], "headers": ["vtkSMPContourGrid.h", "vtkSMPMergePoints.h", "vtkSMPMergePolyDataHelper.h", "vtkFiltersSMPModule.h"], "licenses": []}, "VTK::FiltersReduction": {"library_name": "vtkFiltersReduction", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Filters", "depends": ["VTK::CommonCore", "VTK::CommonExecutionModel"], "optional_depends": [], "private_depends": ["VTK::CommonDataModel"], "implements": [], "headers": ["vtkToAffineArrayStrategy.h", "vtkToConstantArrayStrategy.h", "vtkToImplicitArrayFilter.h", "vtkToImplicitRamerDouglasPeuckerStrategy.h", "vtkToImplicitStrategy.h", "vtkToImplicitTypeErasureStrategy.h", "vtkFiltersReductionModule.h"], "licenses": []}, "VTK::FiltersProgrammable": {"library_name": "vtkFiltersProgrammable", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Filters", "depends": ["VTK::CommonExecutionModel"], "optional_depends": [], "private_depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::CommonTransforms"], "implements": [], "headers": ["vtkProgrammableAttributeDataFilter.h", "vtkProgrammableFilter.h", "vtkProgrammableGlyphFilter.h", "vtkFiltersProgrammableModule.h"], "licenses": []}, "VTK::FiltersPoints": {"library_name": "vtkFiltersPoints", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Filters", "depends": ["VTK::CommonCore", "VTK::CommonExecutionModel", "VTK::CommonMisc", "VTK::FiltersModeling"], "optional_depends": [], "private_depends": [], "implements": [], "headers": ["vtkBoundedPointSource.h", "vtkConnectedPointsFilter.h", "vtkConvertToPointCloud.h", "vtkDensifyPointCloudFilter.h", "vtkEllipsoidalGaussianKernel.h", "vtkEuclideanClusterExtraction.h", "vtkExtractEnclosedPoints.h", "vtkExtractHierarchicalBins.h", "vtkExtractPointCloudPiece.h", "vtkExtractPoints.h", "vtkExtractSurface.h", "vtkFitImplicitFunction.h", "vtkGaussianKernel.h", "vtkGeneralizedKernel.h", "vtkHierarchicalBinningFilter.h", "vtkInterpolationKernel.h", "vtkLinearKernel.h", "vtkMaskPointsFilter.h", "vtkPCACurvatureEstimation.h", "vtkPCANormalEstimation.h", "vtkPointCloudFilter.h", "vtkPointDensityFilter.h", "vtkPointInterpolator.h", "vtkPointInterpolator2D.h", "vtkPointOccupancyFilter.h", "vtkPointSmoothingFilter.h", "vtkPoissonDiskSampler.h", "vtkProbabilisticVoronoiKernel.h", "vtkProjectPointsToPlane.h", "vtkRadiusOutlierRemoval.h", "vtkSPHCubicKernel.h", "vtkSPHInterpolator.h", "vtkSPHKernel.h", "vtkSPHQuarticKernel.h", "vtkSPHQuinticKernel.h", "vtkShepardKernel.h", "vtkSignedDistance.h", "vtkStatisticalOutlierRemoval.h", "vtkUnsignedDistance.h", "vtkVoronoiKernel.h", "vtkVoxelGrid.h", "vtkWendlandQuinticKernel.h", "vtkFiltersPointsModule.h"], "licenses": []}, "VTK::FiltersParallelImaging": {"library_name": "vtkFiltersParallelImaging", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Parallel", "depends": ["VTK::CommonExecutionModel", "VTK::FiltersImaging", "VTK::FiltersParallel", "VTK::ImagingCore"], "optional_depends": [], "private_depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::CommonSystem", "VTK::FiltersExtraction", "VTK::FiltersStatistics", "VTK::ImagingGeneral", "VTK::ParallelCore"], "implements": [], "headers": ["vtkExtractPiece.h", "vtkMemoryLimitImageDataStreamer.h", "vtkPComputeHistogram2DOutliers.h", "vtkPExtractHistogram2D.h", "vtkPPairwiseExtractHistogram2D.h", "vtkTransmitImageDataPiece.h", "vtkFiltersParallelImagingModule.h"], "licenses": []}, "VTK::FiltersImaging": {"library_name": "vtkFiltersImaging", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Filters", "depends": ["VTK::CommonCore", "VTK::CommonExecutionModel", "VTK::FiltersStatistics"], "optional_depends": [], "private_depends": ["VTK::CommonDataModel", "VTK::CommonSystem", "VTK::ImagingGeneral"], "implements": [], "headers": ["vtkComputeHistogram2DOutliers.h", "vtkExtractHistogram2D.h", "vtkPairwiseExtractHistogram2D.h", "vtkFiltersImagingModule.h"], "licenses": []}, "VTK::ImagingGeneral": {"library_name": "vtkImagingGeneral", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Imaging", "depends": ["VTK::CommonExecutionModel", "VTK::ImagingCore"], "optional_depends": [], "private_depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::ImagingSources"], "implements": [], "headers": ["vtkImageAnisotropicDiffusion2D.h", "vtkImageAnisotropicDiffusion3D.h", "vtkImageCheckerboard.h", "vtkImageCityBlockDistance.h", "vtkImageConvolve.h", "vtkImageCorrelation.h", "vtkImageEuclideanDistance.h", "vtkImageEuclideanToPolar.h", "vtkImageGaussianSmooth.h", "vtkImageGradient.h", "vtkImageGradientMagnitude.h", "vtkImageHybridMedian2D.h", "vtkImageLaplacian.h", "vtkImageMedian3D.h", "vtkImageNormalize.h", "vtkImageRange3D.h", "vtkImageSeparableConvolution.h", "vtkImageSlab.h", "vtkImageSlabReslice.h", "vtkImageSobel2D.h", "vtkImageSobel3D.h", "vtkImageSpatialAlgorithm.h", "vtkImageVariance3D.h", "vtkImagingGeneralModule.h"], "licenses": []}, "VTK::FiltersGeometryPreview": {"library_name": "vtkFiltersGeometryPreview", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Filters", "depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::CommonExecutionModel"], "optional_depends": [], "private_depends": [], "implements": [], "headers": ["vtkOctreeImageToPointSetFilter.h", "vtkPointSetToOctreeImageFilter.h", "vtkPointSetStreamer.h", "vtkFiltersGeometryPreviewModule.h"], "licenses": []}, "VTK::FiltersGeneric": {"library_name": "vtkFiltersGeneric", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Filters", "depends": ["VTK::CommonExecutionModel", "VTK::CommonMath"], "optional_depends": [], "private_depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::CommonMisc", "VTK::CommonSystem", "VTK::CommonTransforms", "VTK::FiltersCore", "VTK::FiltersSources"], "implements": [], "headers": ["vtkGenericClip.h", "vtkGenericContourFilter.h", "vtkGenericCutter.h", "vtkGenericDataSetTessellator.h", "vtkGenericGeometryFilter.h", "vtkGenericGlyph3DFilter.h", "vtkGenericOutlineFilter.h", "vtkGenericProbeFilter.h", "vtkGenericStreamTracer.h", "vtkFiltersGenericModule.h"], "licenses": []}, "VTK::FiltersFlowPaths": {"library_name": "vtkFiltersFlowPaths", "description": "", "enabled": true, "implementable": true, "third_party": false, "wrap_exclude": false, "kit": null, "depends": ["VTK::CommonCore", "VTK::CommonComputationalGeometry", "VTK::CommonDataModel", "VTK::CommonExecutionModel", "VTK::CommonMath"], "optional_depends": [], "private_depends": ["VTK::FiltersCore", "VTK::FiltersGeneral", "VTK::FiltersGeometry", "VTK::FiltersModeling", "VTK::FiltersSources", "VTK::IOCore", "VTK::eigen"], "implements": [], "headers": ["vtkAbstractInterpolatedVelocityField.h", "vtkAMRInterpolatedVelocityField.h", "vtkCachingInterpolatedVelocityField.h", "vtkCellLocatorInterpolatedVelocityField.h", "vtkCompositeInterpolatedVelocityField.h", "vtkEvenlySpacedStreamlines2D.h", "vtkInterpolatedVelocityField.h", "vtkLagrangianBasicIntegrationModel.h", "vtkLagrangianMatidaIntegrationModel.h", "vtkLagrangianParticle.h", "vtkLagrangianParticleTracker.h", "vtkLinearTransformCellLocator.h", "vtkModifiedBSPTree.h", "vtkParallelVectors.h", "vtkParticlePathFilter.h", "vtkParticleTracer.h", "vtkParticleTracerBase.h", "vtkStreaklineFilter.h", "vtkStreamSurface.h", "vtkStreamTracer.h", "vtkTemporalInterpolatedVelocityField.h", "vtkVectorFieldTopology.h", "vtkVortexCore.h", "vtkFiltersFlowPathsModule.h"], "licenses": []}, "VTK::eigen": {"library_name": "vtkeigen", "description": "", "enabled": true, "implementable": false, "third_party": true, "wrap_exclude": false, "kit": null, "depends": [], "optional_depends": [], "private_depends": [], "implements": [], "headers": [], "licenses": []}, "VTK::FiltersCellGrid": {"library_name": "vtkFiltersCellGrid", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Filters", "depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::CommonExecutionModel"], "optional_depends": [], "private_depends": ["VTK::FiltersCore"], "implements": [], "headers": ["vtkCellGridComputeSurface.h", "vtkDGBoundsResponder.h", "vtkDGCell.h", "vtkDGHex.h", "vtkDGSidesResponder.h", "vtkDGTet.h", "vtkFiltersCellGridModule.h"], "licenses": []}, "VTK::FiltersAMR": {"library_name": "vtkFiltersAMR", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Parallel", "depends": ["VTK::CommonDataModel", "VTK::CommonExecutionModel"], "optional_depends": [], "private_depends": ["VTK::CommonCore", "VTK::CommonMath", "VTK::CommonSystem", "VTK::FiltersCore", "VTK::IOXML", "VTK::ParallelCore"], "implements": [], "headers": ["vtkAMRCutPlane.h", "vtkAMRGaussianPulseSource.h", "vtkAMRResampleFilter.h", "vtkAMRSliceFilter.h", "vtkAMRToMultiBlockFilter.h", "vtkImageToAMR.h", "vtkParallelAMRUtilities.h", "vtkFiltersAMRModule.h"], "licenses": []}, "VTK::FiltersParallel": {"library_name": "vtkFiltersParallel", "description": "", "enabled": true, "implementable": true, "third_party": false, "wrap_exclude": false, "kit": "VTK::Parallel", "depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::CommonExecutionModel", "VTK::FiltersCore", "VTK::FiltersExtraction", "VTK::FiltersGeneral", "VTK::FiltersGeometry", "VTK::FiltersHybrid", "VTK::FiltersHyperTree", "VTK::FiltersModeling", "VTK::FiltersSources", "VTK::FiltersTexture", "VTK::ParallelCore"], "optional_depends": [], "private_depends": ["VTK::CommonSystem", "VTK::CommonTransforms", "VTK::IOLegacy"], "implements": ["VTK::FiltersCore"], "headers": ["vtkBlockDistribution.h", "vtkAdaptiveTemporalInterpolator.h", "vtkAggregateDataSetFilter.h", "vtkAlignImageDataSetFilter.h", "vtkAngularPeriodicFilter.h", "vtkCollectGraph.h", "vtkCollectPolyData.h", "vtkCollectTable.h", "vtkCutMaterial.h", "vtkDistributedDataFilter.h", "vtkDuplicatePolyData.h", "vtkExtractCTHPart.h", "vtkExtractPolyDataPiece.h", "vtkExtractUnstructuredGridPiece.h", "vtkExtractUserDefinedPiece.h", "vtkGenerateProcessIds.h", "vtkHyperTreeGridGhostCellsGenerator.h", "vtkPHyperTreeGridProbeFilter.h", "vtkIntegrateAttributes.h", "vtkPeriodicFilter.h", "vtkPCellDataToPointData.h", "vtkPConvertToMultiBlockDataSet.h", "vtkPExtractDataArraysOverTime.h", "vtkPExtractExodusGlobalTemporalVariables.h", "vtkPExtractSelectedArraysOverTime.h", "vtkPieceRequestFilter.h", "vtkPieceScalars.h", "vtkPipelineSize.h", "vtkPKdTree.h", "vtkPLinearExtrusionFilter.h", "vtkPMaskPoints.h", "vtkPMergeArrays.h", "vtkPOutlineCornerFilter.h", "vtkPOutlineFilter.h", "vtkPOutlineFilterInternals.h", "vtkPPolyDataNormals.h", "vtkPProbeFilter.h", "vtkPProjectSphereFilter.h", "vtkPReflectionFilter.h", "vtkPResampleFilter.h", "vtkPartitionBalancer.h", "vtkProcessIdScalars.h", "vtkPSphereSource.h", "vtkPTextureMapToSphere.h", "vtkPYoungsMaterialInterface.h", "vtkRectilinearGridOutlineFilter.h", "vtkRemoveGhosts.h", "vtkTransmitPolyDataPiece.h", "vtkTransmitRectilinearGridPiece.h", "vtkTransmitStructuredDataPiece.h", "vtkTransmitStructuredGridPiece.h", "vtkTransmitUnstructuredGridPiece.h", "vtkFiltersParallelModule.h"], "licenses": []}, "VTK::FiltersTexture": {"library_name": "vtkFiltersTexture", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Filters", "depends": ["VTK::CommonExecutionModel"], "optional_depends": [], "private_depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::CommonTransforms", "VTK::FiltersGeneral"], "implements": [], "headers": ["vtkImplicitTextureCoords.h", "vtkScalarsToTextureFilter.h", "vtkTextureMapToCylinder.h", "vtkTextureMapToPlane.h", "vtkTextureMapToSphere.h", "vtkThresholdTextureCoords.h", "vtkTransformTextureCoords.h", "vtkTriangularTCoords.h", "vtkFiltersTextureModule.h"], "licenses": []}, "VTK::FiltersModeling": {"library_name": "vtkFiltersModeling", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Filters", "depends": ["VTK::CommonExecutionModel", "VTK::CommonMisc", "VTK::FiltersGeneral"], "optional_depends": [], "private_depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::CommonTransforms", "VTK::FiltersCore", "VTK::FiltersSources"], "implements": [], "headers": ["vtkAdaptiveSubdivisionFilter.h", "vtkBandedPolyDataContourFilter.h", "vtkButterflySubdivisionFilter.h", "vtkCollisionDetectionFilter.h", "vtkContourLoopExtraction.h", "vtkCookieCutter.h", "vtkDijkstraGraphGeodesicPath.h", "vtkDijkstraImageGeodesicPath.h", "vtkFillHolesFilter.h", "vtkFitToHeightMapFilter.h", "vtkGeodesicPath.h", "vtkGraphGeodesicPath.h", "vtkHausdorffDistancePointSetFilter.h", "vtkHyperTreeGridOutlineFilter.h", "vtkImageDataOutlineFilter.h", "vtkImprintFilter.h", "vtkLinearCellExtrusionFilter.h", "vtkLinearExtrusionFilter.h", "vtkLinearSubdivisionFilter.h", "vtkLoopSubdivisionFilter.h", "vtkOutlineFilter.h", "vtkPolyDataPointSampler.h", "vtkProjectedTexture.h", "vtkQuadRotationalExtrusionFilter.h", "vtkRibbonFilter.h", "vtkRotationalExtrusionFilter.h", "vtkRuledSurfaceFilter.h", "vtkSectorSource.h", "vtkSelectEnclosedPoints.h", "vtkSelectPolyData.h", "vtkSpherePuzzle.h", "vtkSpherePuzzleArrows.h", "vtkSubdivideTetra.h", "vtkTrimmedExtrusionFilter.h", "vtkVolumeOfRevolutionFilter.h", "vtkFiltersModelingModule.h"], "licenses": []}, "VTK::DomainsChemistryOpenGL2": {"library_name": "vtkDomainsChemistryOpenGL2", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": null, "depends": ["VTK::CommonCore", "VTK::DomainsChemistry", "VTK::RenderingOpenGL2"], "optional_depends": [], "private_depends": ["VTK::CommonDataModel", "VTK::CommonExecutionModel", "VTK::CommonMath", "VTK::glew", "VTK::RenderingCore"], "implements": ["VTK::DomainsChemistry"], "headers": ["vtkOpenGLMoleculeMapper.h", "vtkDomainsChemistryOpenGL2Module.h"], "licenses": []}, "VTK::RenderingOpenGL2": {"library_name": "vtkRenderingOpenGL2", "description": "", "enabled": true, "implementable": true, "third_party": false, "wrap_exclude": false, "kit": "VTK::OpenGL", "depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::FiltersGeneral", "VTK::IOImage", "VTK::RenderingCore", "VTK::RenderingHyperTreeGrid", "VTK::RenderingUI", "VTK::glew"], "optional_depends": [], "private_depends": ["VTK::CommonExecutionModel", "VTK::CommonMath", "VTK::CommonSystem", "VTK::CommonTransforms", "VTK::opengl", "VTK::vtksys"], "implements": ["VTK::RenderingCore"], "headers": ["vtkOpenGLError.h", "vtkRenderingOpenGLConfigure.h", "vtkCameraPass.h", "vtkClearRGBPass.h", "vtkClearZPass.h", "vtkCompositePolyDataMapper2.h", "vtkDataTransferHelper.h", "vtkDefaultPass.h", "vtkDepthImageProcessingPass.h", "vtkDepthOfFieldPass.h", "vtkDepthPeelingPass.h", "vtkDualDepthPeelingPass.h", "vtkEDLShading.h", "vtkEquirectangularToCubeMapTexture.h", "vtkFramebufferPass.h", "vtkGaussianBlurPass.h", "vtkGenericOpenGLRenderWindow.h", "vtkHiddenLineRemovalPass.h", "vtkImageProcessingPass.h", "vtkLightingMapPass.h", "vtkLightsPass.h", "vtkOpaquePass.h", "vtkOpenGLActor.h", "vtkOpenGLBatchedPolyDataMapper.h", "vtkOpenGLBillboardTextActor3D.h", "vtkOpenGLBufferObject.h", "vtkOpenGLCamera.h", "vtkOpenGLCellToVTKCellMap.h", "vtkOpenGLCompositePolyDataMapperDelegator.h", "vtkOpenGLFXAAFilter.h", "vtkOpenGLFXAAPass.h", "vtkOpenGLFluidMapper.h", "vtkOpenGLFramebufferObject.h", "vtkOpenGLGL2PSHelper.h", "vtkOpenGLGlyph3DHelper.h", "vtkOpenGLGlyph3DMapper.h", "vtkOpenGLHardwareSelector.h", "vtkOpenGLHelper.h", "vtkOpenGLHyperTreeGridMapper.h", "vtkOpenGLImageAlgorithmHelper.h", "vtkOpenGLImageMapper.h", "vtkOpenGLImageSliceMapper.h", "vtkOpenGLIndexBufferObject.h", "vtkOpenGLInstanceCulling.h", "vtkOpenGLLabeledContourMapper.h", "vtkOpenGLLight.h", "vtkOpenGLPointGaussianMapper.h", "vtkOpenGLPolyDataMapper.h", "vtkOpenGLPolyDataMapper2D.h", "vtkOpenGLProperty.h", "vtkOpenGLQuadHelper.h", "vtkOpenGLRenderPass.h", "vtkOpenGLRenderTimer.h", "vtkOpenGLRenderTimerLog.h", "vtkOpenGLRenderUtilities.h", "vtkOpenGLRenderWindow.h", "vtkOpenGLRenderer.h", "vtkOpenGLShaderCache.h", "vtkOpenGLShaderProperty.h", "vtkOpenGLSkybox.h", "vtkOpenGLSphereMapper.h", "vtkOpenGLState.h", "vtkOpenGLStickMapper.h", "vtkOpenGLTextActor.h", "vtkOpenGLTextActor3D.h", "vtkOpenGLTextMapper.h", "vtkOpenGLTexture.h", "vtkOpenGLUniforms.h", "vtkOpenGLVertexArrayObject.h", "vtkOpenGLVertexBufferObject.h", "vtkOpenGLVertexBufferObjectCache.h", "vtkOpenGLVertexBufferObjectGroup.h", "vtkOrderIndependentTranslucentPass.h", "vtkOutlineGlowPass.h", "vtkOverlayPass.h", "vtkPBRIrradianceTexture.h", "vtkPBRLUTTexture.h", "vtkPBRPrefilterTexture.h", "vtkPanoramicProjectionPass.h", "vtkPixelBufferObject.h", "vtkPointFillPass.h", "vtkRenderPassCollection.h", "vtkRenderStepsPass.h", "vtkRenderbuffer.h", "vtkSSAAPass.h", "vtkSSAOPass.h", "vtkSequencePass.h", "vtkShader.h", "vtkShaderProgram.h", "vtkShadowMapBakerPass.h", "vtkShadowMapPass.h", "vtkSimpleMotionBlurPass.h", "vtkSobelGradientMagnitudePass.h", "vtkTextureObject.h", "vtkTextureUnitManager.h", "vtkToneMappingPass.h", "vtkTransformFeedback.h", "vtkTranslucentPass.h", "vtkValuePass.h", "vtkVolumetricPass.h", "vtkDummyGPUInfoList.h", "vtkXOpenGLRenderWindow.h", "vtkRenderingOpenGL2Module.h"], "licenses": []}, "VTK::RenderingHyperTreeGrid": {"library_name": "vtkRenderingHyperTreeGrid", "description": "", "enabled": true, "implementable": true, "third_party": false, "wrap_exclude": false, "kit": null, "depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::CommonExecutionModel", "VTK::CommonMath", "VTK::RenderingCore"], "optional_depends": [], "private_depends": ["VTK::FiltersHybrid", "VTK::FiltersHyperTree"], "implements": [], "headers": ["vtkHyperTreeGridMapper.h", "vtkRenderingHyperTreeGridModule.h"], "licenses": []}, "VTK::RenderingUI": {"library_name": "vtkRenderingUI", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": null, "depends": ["VTK::RenderingCore"], "optional_depends": [], "private_depends": [], "implements": ["VTK::RenderingCore"], "headers": ["vtkGenericRenderWindowInteractor.h", "vtkXRenderWindowInteractor.h", "vtkRenderingUIModule.h"], "licenses": []}, "VTK::FiltersHybrid": {"library_name": "vtkFiltersHybrid", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": null, "depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::CommonExecutionModel", "VTK::CommonTransforms", "VTK::FiltersGeometry"], "optional_depends": [], "private_depends": ["VTK::CommonMath", "VTK::CommonMisc", "VTK::FiltersCore", "VTK::FiltersGeneral", "VTK::ImagingCore", "VTK::ImagingSources", "VTK::RenderingCore", "VTK::vtksys"], "implements": [], "headers": ["vtkAdaptiveDataSetSurfaceFilter.h", "vtkBSplineTransform.h", "vtkDepthSortPolyData.h", "vtkDSPFilterDefinition.h", "vtkDSPFilterGroup.h", "vtkEarthSource.h", "vtkFacetReader.h", "vtkForceTime.h", "vtkGenerateTimeSteps.h", "vtkGreedyTerrainDecimation.h", "vtkGridTransform.h", "vtkImageToPolyDataFilter.h", "vtkImplicitModeller.h", "vtkPCAAnalysisFilter.h", "vtkPolyDataSilhouette.h", "vtkProcrustesAlignmentFilter.h", "vtkProjectedTerrainPath.h", "vtkRenderLargeImage.h", "vtkTemporalArrayOperatorFilter.h", "vtkTemporalDataSetCache.h", "vtkTemporalFractal.h", "vtkTemporalInterpolator.h", "vtkTemporalShiftScale.h", "vtkTemporalSnapToTimeStep.h", "vtkTransformToGrid.h", "vtkWeightedTransformFilter.h", "vtkFiltersHybridModule.h"], "licenses": []}, "VTK::DomainsChemistry": {"library_name": "vtkDomainsChemistry", "description": "", "enabled": true, "implementable": true, "third_party": false, "wrap_exclude": false, "kit": null, "depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::CommonExecutionModel", "VTK::IOLegacy", "VTK::IOXMLParser", "VTK::RenderingCore"], "optional_depends": [], "private_depends": ["VTK::CommonTransforms", "VTK::FiltersCore", "VTK::FiltersGeneral", "VTK::FiltersSources", "VTK::vtksys"], "implements": [], "headers": ["vtkBlueObeliskData.h", "vtkBlueObeliskDataParser.h", "vtkMoleculeMapper.h", "vtkMoleculeToAtomBallFilter.h", "vtkMoleculeToBondStickFilter.h", "vtkMoleculeToLinesFilter.h", "vtkMoleculeToPolyDataFilter.h", "vtkPeriodicTable.h", "vtkPointSetToMoleculeFilter.h", "vtkProgrammableElectronicData.h", "vtkProteinRibbonFilter.h", "vtkSimpleBondPerceiver.h", "vtkDomainsChemistryModule.h"], "licenses": []}, "VTK::ChartsCore": {"library_name": "vtkChartsCore", "description": "", "enabled": true, "implementable": true, "third_party": false, "wrap_exclude": false, "kit": null, "depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::FiltersGeneral", "VTK::RenderingContext2D", "VTK::RenderingCore", "VTK::vtksys"], "optional_depends": [], "private_depends": ["VTK::CommonColor", "VTK::CommonExecutionModel", "VTK::CommonTransforms", "VTK::InfovisCore"], "implements": [], "headers": ["vtkAxis.h", "vtkAxisExtended.h", "vtkCategoryLegend.h", "vtkChart.h", "vtkChartBox.h", "vtkChartHistogram2D.h", "vtkChartLegend.h", "vtkChartMatrix.h", "vtkChartParallelCoordinates.h", "vtkChartPie.h", "vtkChartXY.h", "vtkChartXYZ.h", "vtkColorLegend.h", "vtkColorTransferControlPointsItem.h", "vtkColorTransferFunctionItem.h", "vtkCompositeControlPointsItem.h", "vtkCompositeTransferFunctionItem.h", "vtkContextArea.h", "vtkContextPolygon.h", "vtkControlPointsItem.h", "vtkInteractiveArea.h", "vtkLookupTableItem.h", "vtkPiecewiseControlPointsItem.h", "vtkPiecewiseFunctionItem.h", "vtkPiecewisePointHandleItem.h", "vtkPlot.h", "vtkPlot3D.h", "vtkPlotArea.h", "vtkPlotBag.h", "vtkPlotBar.h", "vtkPlotBarRangeHandlesItem.h", "vtkPlotBox.h", "vtkPlotFunctionalBag.h", "vtkPlotGrid.h", "vtkPlotHistogram2D.h", "vtkPlotLine.h", "vtkPlotLine3D.h", "vtkPlotParallelCoordinates.h", "vtkPlotPie.h", "vtkPlotPoints.h", "vtkPlotPoints3D.h", "vtkPlotRangeHandlesItem.h", "vtkPlotStacked.h", "vtkPlotSurface.h", "vtkRangeHandlesItem.h", "vtkScalarsToColorsItem.h", "vtkScatterPlotMatrix.h", "vtkChartsCoreModule.h"], "licenses": []}, "VTK::InfovisCore": {"library_name": "vtkInfovisCore", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": null, "depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::CommonExecutionModel", "VTK::CommonColor", "VTK::IOImage", "VTK::ImagingCore", "VTK::ImagingSources", "VTK::RenderingFreeType"], "optional_depends": [], "private_depends": ["VTK::FiltersExtraction", "VTK::FiltersGeneral"], "implements": [], "headers": ["vtkAddMembershipArray.h", "vtkAdjacencyMatrixToEdgeTable.h", "vtkArrayNorm.h", "vtkArrayToTable.h", "vtkCollapseGraph.h", "vtkCollapseVerticesByArray.h", "vtkContinuousScatterplot.h", "vtkDataObjectToTable.h", "vtkDotProductSimilarity.h", "vtkEdgeCenters.h", "vtkExpandSelectedGraph.h", "vtkExtractSelectedGraph.h", "vtkExtractSelectedTree.h", "vtkGenerateIndexArray.h", "vtkGraphHierarchicalBundleEdges.h", "vtkGroupLeafVertices.h", "vtkKCoreDecomposition.h", "vtkMergeColumns.h", "vtkMergeGraphs.h", "vtkMergeTables.h", "vtkMutableGraphHelper.h", "vtkNetworkHierarchy.h", "vtkPipelineGraphSource.h", "vtkPruneTreeFilter.h", "vtkRandomGraphSource.h", "vtkReduceTable.h", "vtkRemoveHiddenData.h", "vtkRemoveIsolatedVertices.h", "vtkSparseArrayToTable.h", "vtkStreamGraph.h", "vtkStringToCategory.h", "vtkStringToNumeric.h", "vtkTableToArray.h", "vtkTableToGraph.h", "vtkTableToSparseArray.h", "vtkTableToTreeFilter.h", "vtkThresholdGraph.h", "vtkThresholdTable.h", "vtkTransferAttributes.h", "vtkTransposeMatrix.h", "vtkTreeDifferenceFilter.h", "vtkTreeFieldAggregator.h", "vtkTreeLevelsFilter.h", "vtkVertexDegree.h", "vtkWordCloud.h", "vtkInfovisCoreModule.h"], "licenses": []}, "VTK::FiltersExtraction": {"library_name": "vtkFiltersExtraction", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Parallel", "depends": ["VTK::CommonCore", "VTK::CommonExecutionModel", "VTK::FiltersGeneral"], "optional_depends": ["VTK::ParallelMPI"], "private_depends": ["VTK::CommonDataModel", "VTK::FiltersCore", "VTK::FiltersHyperTree", "VTK::FiltersStatistics", "VTK::ParallelDIY"], "implements": [], "headers": ["vtkBlockSelector.h", "vtkConvertSelection.h", "vtkExpandMarkedElements.h", "vtkExtractBlock.h", "vtkExtractBlockUsingDataAssembly.h", "vtkExtractCellsByType.h", "vtkExtractDataArraysOverTime.h", "vtkExtractDataOverTime.h", "vtkExtractDataSets.h", "vtkExtractExodusGlobalTemporalVariables.h", "vtkExtractGeometry.h", "vtkExtractGrid.h", "vtkExtractLevel.h", "vtkExtractParticlesOverTime.h", "vtkExtractPolyDataGeometry.h", "vtkExtractRectilinearGrid.h", "vtkExtractSelectedArraysOverTime.h", "vtkExtractSelectedBlock.h", "vtkExtractSelectedIds.h", "vtkExtractSelectedLocations.h", "vtkExtractSelectedPolyDataIds.h", "vtkExtractSelectedRows.h", "vtkExtractSelectedThresholds.h", "vtkExtractSelection.h", "vtkExtractTensorComponents.h", "vtkExtractTimeSteps.h", "vtkExtractUnstructuredGrid.h", "vtkExtractVectorComponents.h", "vtkFrustumSelector.h", "vtkHierarchicalDataExtractDataSets.h", "vtkHierarchicalDataExtractLevel.h", "vtkLocationSelector.h", "vtkProbeSelectedLocations.h", "vtkSelector.h", "vtkValueSelector.h", "vtkFiltersExtractionModule.h"], "licenses": []}, "VTK::ParallelDIY": {"library_name": "vtkParallelDIY", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Parallel", "depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::CommonSystem", "VTK::ParallelCore", "VTK::diy2"], "optional_depends": ["VTK::ParallelMPI"], "private_depends": ["VTK::FiltersGeneral", "VTK::FiltersGeometry", "VTK::IOXML"], "implements": [], "headers": ["vtkDIYDataExchanger.h", "vtkDIYExplicitAssigner.h", "vtkDIYGhostUtilities.h", "vtkDIYUtilities.h", "vtkParallelDIYModule.h"], "licenses": []}, "VTK::diy2": {"library_name": "vtkdiy2", "description": "", "enabled": true, "implementable": false, "third_party": true, "wrap_exclude": false, "kit": null, "depends": [], "optional_depends": ["VTK::mpi"], "private_depends": [], "implements": [], "headers": [], "licenses": []}, "VTK::IOXML": {"library_name": "vtkIOXML", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::IO", "depends": ["VTK::CommonCore", "VTK::CommonExecutionModel", "VTK::IOXMLParser"], "optional_depends": [], "private_depends": ["VTK::CommonDataModel", "VTK::CommonMisc", "VTK::CommonSystem", "VTK::IOCore", "VTK::vtksys"], "implements": [], "headers": ["vtkRTXMLPolyDataReader.h", "vtkXMLCompositeDataReader.h", "vtkXMLCompositeDataWriter.h", "vtkXMLDataObjectWriter.h", "vtkXMLDataReader.h", "vtkXMLDataSetWriter.h", "vtkXMLFileReadTester.h", "vtkXMLGenericDataObjectReader.h", "vtkXMLHierarchicalBoxDataFileConverter.h", "vtkXMLHierarchicalBoxDataReader.h", "vtkXMLHierarchicalBoxDataWriter.h", "vtkXMLHierarchicalDataReader.h", "vtkXMLHyperTreeGridReader.h", "vtkXMLHyperTreeGridWriter.h", "vtkXMLImageDataReader.h", "vtkXMLImageDataWriter.h", "vtkXMLMultiBlockDataReader.h", "vtkXMLMultiBlockDataWriter.h", "vtkXMLMultiGroupDataReader.h", "vtkXMLPDataObjectReader.h", "vtkXMLPDataReader.h", "vtkXMLPHyperTreeGridReader.h", "vtkXMLPImageDataReader.h", "vtkXMLPPolyDataReader.h", "vtkXMLPRectilinearGridReader.h", "vtkXMLPStructuredDataReader.h", "vtkXMLPStructuredGridReader.h", "vtkXMLPTableReader.h", "vtkXMLPUnstructuredDataReader.h", "vtkXMLPUnstructuredGridReader.h", "vtkXMLPartitionedDataSetCollectionReader.h", "vtkXMLPartitionedDataSetReader.h", "vtkXMLPolyDataReader.h", "vtkXMLPolyDataWriter.h", "vtkXMLReader.h", "vtkXMLRectilinearGridReader.h", "vtkXMLRectilinearGridWriter.h", "vtkXMLStructuredDataReader.h", "vtkXMLStructuredDataWriter.h", "vtkXMLStructuredGridReader.h", "vtkXMLStructuredGridWriter.h", "vtkXMLTableReader.h", "vtkXMLTableWriter.h", "vtkXMLUniformGridAMRReader.h", "vtkXMLUniformGridAMRWriter.h", "vtkXMLUnstructuredDataReader.h", "vtkXMLUnstructuredDataWriter.h", "vtkXMLUnstructuredGridReader.h", "vtkXMLUnstructuredGridWriter.h", "vtkXMLWriter.h", "vtkXMLWriterBase.h", "vtkXMLWriterC.h", "vtkIOXMLModule.h"], "licenses": []}, "VTK::IOXMLParser": {"library_name": "vtkIOXMLParser", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::IO", "depends": ["VTK::CommonCore", "VTK::CommonDataModel"], "optional_depends": [], "private_depends": ["VTK::IOCore", "VTK::expat", "VTK::vtksys"], "implements": [], "headers": ["vtkXMLDataParser.h", "vtkXMLParser.h", "vtkXMLUtilities.h", "vtkIOXMLParserModule.h"], "licenses": []}, "VTK::expat": {"library_name": "vtkexpat", "description": "", "enabled": true, "implementable": false, "third_party": true, "wrap_exclude": false, "kit": null, "depends": [], "optional_depends": [], "private_depends": [], "implements": [], "headers": ["vtkexpat/lib/expat.h", "vtkexpat/lib/expat_external.h", "vtkexpat/lib/vtk_expat_mangle.h"], "licenses": []}, "VTK::ParallelCore": {"library_name": "vtkParallelCore", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Parallel", "depends": ["VTK::CommonCore"], "optional_depends": [], "private_depends": ["VTK::CommonDataModel", "VTK::CommonSystem", "VTK::IOLegacy", "VTK::vtksys"], "implements": [], "headers": ["vtkCommunicator.h", "vtkDummyCommunicator.h", "vtkDummyController.h", "vtkFieldDataSerializer.h", "vtkMultiProcessController.h", "vtkMultiProcessStream.h", "vtkPDirectory.h", "vtkProcess.h", "vtkProcessGroup.h", "vtkPSystemTools.h", "vtkSocketCommunicator.h", "vtkSocketController.h", "vtkSubCommunicator.h", "vtkSubGroup.h", "vtkThreadedCallbackQueue.h", "vtkThreadedTaskQueue.h", "vtkParallelCoreModule.h"], "licenses": []}, "VTK::IOLegacy": {"library_name": "vtkIOLegacy", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::IO", "depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::CommonExecutionModel", "VTK::IOCore"], "optional_depends": [], "private_depends": ["VTK::CommonMisc", "VTK::vtksys"], "implements": [], "headers": ["vtkCompositeDataReader.h", "vtkCompositeDataWriter.h", "vtkDataObjectReader.h", "vtkDataObjectWriter.h", "vtkDataReader.h", "vtkDataSetReader.h", "vtkDataSetWriter.h", "vtkDataWriter.h", "vtkGenericDataObjectReader.h", "vtkGenericDataObjectWriter.h", "vtkGraphReader.h", "vtkGraphWriter.h", "vtkPixelExtentIO.h", "vtkPolyDataReader.h", "vtkPolyDataWriter.h", "vtkRectilinearGridReader.h", "vtkRectilinearGridWriter.h", "vtkSimplePointsReader.h", "vtkSimplePointsWriter.h", "vtkStructuredGridReader.h", "vtkStructuredGridWriter.h", "vtkStructuredPointsReader.h", "vtkStructuredPointsWriter.h", "vtkTableReader.h", "vtkTableWriter.h", "vtkTreeReader.h", "vtkTreeWriter.h", "vtkUnstructuredGridReader.h", "vtkUnstructuredGridWriter.h", "vtkIOLegacyModule.h"], "licenses": []}, "VTK::IOCore": {"library_name": "vtkIOCore", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::IO", "depends": ["VTK::CommonCore", "VTK::CommonExecutionModel"], "optional_depends": [], "private_depends": ["VTK::CommonDataModel", "VTK::CommonMisc", "VTK::doubleconversion", "VTK::lz4", "VTK::lzma", "VTK::utf8", "VTK::vtksys", "VTK::zlib", "VTK::fast_float"], "implements": [], "headers": ["vtkUpdateCellsV8toV9.h", "vtkAbstractParticleWriter.h", "vtkAbstractPolyDataReader.h", "vtkArrayDataReader.h", "vtkArrayDataWriter.h", "vtkArrayReader.h", "vtkArrayWriter.h", "vtkASCIITextCodec.h", "vtkBase64InputStream.h", "vtkBase64OutputStream.h", "vtkBase64Utilities.h", "vtkDataCompressor.h", "vtkDelimitedTextWriter.h", "vtkFileResourceStream.h", "vtkGlobFileNames.h", "vtkInputStream.h", "vtkJavaScriptDataWriter.h", "vtkLZ4DataCompressor.h", "vtkLZMADataCompressor.h", "vtkMemoryResourceStream.h", "vtkNumberToString.h", "vtkOutputStream.h", "vtkResourceParser.h", "vtkResourceStream.h", "vtkSortFileNames.h", "vtkTextCodec.h", "vtkTextCodecFactory.h", "vtkURI.h", "vtkURILoader.h", "vtkUTF16TextCodec.h", "vtkUTF8TextCodec.h", "vtkWriter.h", "vtkZLibDataCompressor.h", "vtkIOCoreModule.h"], "licenses": []}, "VTK::doubleconversion": {"library_name": "vtkdoubleconversion", "description": "", "enabled": true, "implementable": false, "third_party": true, "wrap_exclude": false, "kit": null, "depends": [], "optional_depends": [], "private_depends": [], "implements": [], "headers": ["vtkdoubleconversion/double-conversion/bignum.h", "vtkdoubleconversion/double-conversion/cached-powers.h", "vtkdoubleconversion/double-conversion/diy-fp.h", "vtkdoubleconversion/double-conversion/double-conversion.h", "vtkdoubleconversion/double-conversion/fast-dtoa.h", "vtkdoubleconversion/double-conversion/fixed-dtoa.h", "vtkdoubleconversion/double-conversion/ieee.h", "vtkdoubleconversion/double-conversion/strtod.h", "vtkdoubleconversion/double-conversion/utils.h", "vtkdoubleconversion/vtkdoubleconversion_export.h"], "licenses": []}, "VTK::lz4": {"library_name": "vtklz4", "description": "", "enabled": true, "implementable": false, "third_party": true, "wrap_exclude": false, "kit": null, "depends": [], "optional_depends": [], "private_depends": [], "implements": [], "headers": ["vtklz4/lib/lz4.h", "vtklz4/lib/lz4hc.h", "vtklz4/lib/lz4frame.h", "vtklz4/lib/lz4frame_static.h"], "licenses": []}, "VTK::lzma": {"library_name": "vtklzma", "description": "", "enabled": true, "implementable": false, "third_party": true, "wrap_exclude": false, "kit": null, "depends": [], "optional_depends": [], "private_depends": [], "implements": [], "headers": ["vtklzma/src/liblzma/api/lzma.h", "vtklzma/src/liblzma/api/lzma/base.h", "vtklzma/src/liblzma/api/lzma/bcj.h", "vtklzma/src/liblzma/api/lzma/block.h", "vtklzma/src/liblzma/api/lzma/check.h", "vtklzma/src/liblzma/api/lzma/container.h", "vtklzma/src/liblzma/api/lzma/delta.h", "vtklzma/src/liblzma/api/lzma/filter.h", "vtklzma/src/liblzma/api/lzma/hardware.h", "vtklzma/src/liblzma/api/lzma/index.h", "vtklzma/src/liblzma/api/lzma/index_hash.h", "vtklzma/src/liblzma/api/lzma/lzma12.h", "vtklzma/src/liblzma/api/lzma/stream_flags.h", "vtklzma/src/liblzma/api/lzma/version.h", "vtklzma/src/liblzma/api/lzma/vli.h", "vtklzma/src/liblzma/api/vtk_lzma_mangle.h"], "licenses": []}, "VTK::fast_float": {"library_name": "vtkfast_float", "description": "", "enabled": true, "implementable": false, "third_party": true, "wrap_exclude": false, "kit": null, "depends": [], "optional_depends": [], "private_depends": [], "implements": [], "headers": [], "licenses": []}, "VTK::FiltersStatistics": {"library_name": "vtkFiltersStatistics", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Filters", "depends": ["VTK::CommonCore", "VTK::CommonExecutionModel"], "optional_depends": [], "private_depends": ["VTK::CommonDataModel", "VTK::CommonMath", "VTK::CommonMisc", "VTK::eigen", "VTK::FiltersGeneral"], "implements": [], "headers": ["vtkAutoCorrelativeStatistics.h", "vtkBivariateLinearTableThreshold.h", "vtkComputeQuantiles.h", "vtkComputeQuartiles.h", "vtkContingencyStatistics.h", "vtkCorrelativeStatistics.h", "vtkDescriptiveStatistics.h", "vtkExtractFunctionalBagPlot.h", "vtkExtractHistogram.h", "vtkHighestDensityRegionsStatistics.h", "vtkKMeansDistanceFunctor.h", "vtkKMeansDistanceFunctorCalculator.h", "vtkKMeansStatistics.h", "vtkLengthDistribution.h", "vtkMultiCorrelativeStatistics.h", "vtkOrderStatistics.h", "vtkPCAStatistics.h", "vtkStatisticsAlgorithm.h", "vtkStrahlerMetric.h", "vtkStreamingStatistics.h", "vtkFiltersStatisticsModule.h"], "licenses": []}, "VTK::FiltersHyperTree": {"library_name": "vtkFiltersHyperTree", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Filters", "depends": ["VTK::CommonDataModel", "VTK::CommonExecutionModel", "VTK::CommonMisc", "VTK::FiltersCore", "VTK::FiltersGeneral"], "optional_depends": [], "private_depends": ["VTK::CommonCore", "VTK::CommonSystem"], "implements": [], "headers": ["vtkHyperTreeGridAxisClip.h", "vtkHyperTreeGridAxisCut.h", "vtkHyperTreeGridAxisReflection.h", "vtkHyperTreeGridCellCenters.h", "vtkHyperTreeGridContour.h", "vtkHyperTreeGridDepthLimiter.h", "vtkHyperTreeGridEvaluateCoarse.h", "vtkHyperTreeGridGeometry.h", "vtkHyperTreeGridGradient.h", "vtkHyperTreeGridPlaneCutter.h", "vtkHyperTreeGridThreshold.h", "vtkHyperTreeGridToDualGrid.h", "vtkHyperTreeGridToUnstructuredGrid.h", "vtkImageDataToHyperTreeGrid.h", "vtkFiltersHyperTreeModule.h"], "licenses": []}, "VTK::ImagingSources": {"library_name": "vtkImagingSources", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Imaging", "depends": ["VTK::CommonExecutionModel"], "optional_depends": [], "private_depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::ImagingCore"], "implements": [], "headers": ["vtkImageCanvasSource2D.h", "vtkImageEllipsoidSource.h", "vtkImageGaussianSource.h", "vtkImageGridSource.h", "vtkImageMandelbrotSource.h", "vtkImageNoiseSource.h", "vtkImageSinusoidSource.h", "vtkImagingSourcesModule.h"], "licenses": []}, "VTK::IOImage": {"library_name": "vtkIOImage", "description": "", "enabled": true, "implementable": true, "third_party": false, "wrap_exclude": false, "kit": "VTK::IO", "depends": ["VTK::CommonCore", "VTK::CommonExecutionModel", "VTK::ImagingCore"], "optional_depends": [], "private_depends": ["VTK::CommonDataModel", "VTK::CommonMath", "VTK::CommonMisc", "VTK::CommonSystem", "VTK::CommonTransforms", "VTK::DICOMParser", "VTK::jpeg", "VTK::metaio", "VTK::png", "VTK::pugixml", "VTK::tiff", "VTK::vtksys", "VTK::zlib"], "implements": [], "headers": ["vtkBMPReader.h", "vtkBMPWriter.h", "vtkDEMReader.h", "vtkDICOMImageReader.h", "vtkGESignaReader.h", "vtkHDRReader.h", "vtkImageExport.h", "vtkImageImport.h", "vtkImageImportExecutive.h", "vtkImageReader.h", "vtkImageReader2.h", "vtkImageReader2Collection.h", "vtkImageReader2Factory.h", "vtkImageWriter.h", "vtkJPEGReader.h", "vtkJPEGWriter.h", "vtkJSONImageWriter.h", "vtkMedicalImageProperties.h", "vtkMedicalImageReader2.h", "vtkMetaImageReader.h", "vtkMetaImageWriter.h", "vtkMRCReader.h", "vtkNIFTIImageHeader.h", "vtkNIFTIImageReader.h", "vtkNIFTIImageWriter.h", "vtkNrrdReader.h", "vtkOMETIFFReader.h", "vtkPNGReader.h", "vtkPNGWriter.h", "vtkPNMReader.h", "vtkPNMWriter.h", "vtkPostScriptWriter.h", "vtkSEPReader.h", "vtkSLCReader.h", "vtkTGAReader.h", "vtkTIFFReader.h", "vtkTIFFWriter.h", "vtkVolume16Reader.h", "vtkVolumeReader.h", "vtkIOImageModule.h"], "licenses": []}, "VTK::DICOMParser": {"library_name": "vtkDICOMParser", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": null, "depends": [], "optional_depends": [], "private_depends": ["VTK::CommonCore", "VTK::vtksys"], "implements": [], "headers": ["DICOMAppHelper.h", "DICOMCallback.h", "DICOMConfig.h", "DICOMFile.h", "DICOMParser.h", "DICOMParserMap.h", "DICOMTypes.h", "DICOMCMakeConfig.h", "vtkDICOMParserModule.h"], "licenses": []}, "VTK::jpeg": {"library_name": "vtkjpeg", "description": "", "enabled": true, "implementable": false, "third_party": true, "wrap_exclude": false, "kit": null, "depends": [], "optional_depends": [], "private_depends": [], "implements": [], "headers": ["vtkjpeg/jerror.h", "vtkjpeg/jmorecfg.h", "vtkjpeg/jpeglib.h", "vtkjpeg/vtk_jpeg_mangle.h", "vtkjpeg/jconfig.h"], "licenses": []}, "VTK::metaio": {"library_name": "vtkmetaio", "description": "", "enabled": true, "implementable": false, "third_party": true, "wrap_exclude": false, "kit": null, "depends": [], "optional_depends": [], "private_depends": ["VTK::zlib"], "implements": [], "headers": ["vtkmetaio/localMetaConfiguration.h", "vtkmetaio/metaArray.h", "vtkmetaio/metaArrow.h", "vtkmetaio/metaBlob.h", "vtkmetaio/metaCommand.h", "vtkmetaio/metaContour.h", "vtkmetaio/metaDTITube.h", "vtkmetaio/metaEllipse.h", "vtkmetaio/metaEvent.h", "vtkmetaio/metaFEMObject.h", "vtkmetaio/metaForm.h", "vtkmetaio/metaGaussian.h", "vtkmetaio/metaGroup.h", "vtkmetaio/metaImage.h", "vtkmetaio/metaImageTypes.h", "vtkmetaio/metaImageUtils.h", "vtkmetaio/metaLandmark.h", "vtkmetaio/metaLine.h", "vtkmetaio/metaMesh.h", "vtkmetaio/metaObject.h", "vtkmetaio/metaScene.h", "vtkmetaio/metaSurface.h", "vtkmetaio/metaTube.h", "vtkmetaio/metaTransform.h", "vtkmetaio/metaTubeGraph.h", "vtkmetaio/metaTypes.h", "vtkmetaio/metaUtils.h", "vtkmetaio/metaVesselTube.h", "vtkmetaio/metaIOConfig.h"], "licenses": []}, "VTK::tiff": {"library_name": "vtktiff", "description": "", "enabled": true, "implementable": false, "third_party": true, "wrap_exclude": false, "kit": null, "depends": [], "optional_depends": [], "private_depends": ["VTK::jpeg", "VTK::zlib"], "implements": [], "headers": ["vtktiff/libtiff/tiff.h", "vtktiff/libtiff/tiffio.h", "vtktiff/libtiff/tiffvers.h", "vtktiff/libtiff/vtk_tiff_mangle.h", "vtktiff/libtiff/tiffconf.h"], "licenses": []}, "VTK::RenderingContext2D": {"library_name": "vtkRenderingContext2D", "description": "", "enabled": true, "implementable": true, "third_party": false, "wrap_exclude": false, "kit": "VTK::Rendering", "depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::CommonExecutionModel", "VTK::RenderingCore"], "optional_depends": [], "private_depends": ["VTK::CommonMath", "VTK::CommonSystem", "VTK::CommonTransforms", "VTK::FiltersGeneral", "VTK::RenderingFreeType"], "implements": [], "headers": ["vtkAbstractContextBufferId.h", "vtkAbstractContextItem.h", "vtkBlockItem.h", "vtkBrush.h", "vtkContext2D.h", "vtkContext3D.h", "vtkContextActor.h", "vtkContextClip.h", "vtkContextDevice2D.h", "vtkContextDevice3D.h", "vtkContextItem.h", "vtkContextKeyEvent.h", "vtkContextMapper2D.h", "vtkContextMouseEvent.h", "vtkContextScene.h", "vtkContextTransform.h", "vtkImageItem.h", "vtkLabeledContourPolyDataItem.h", "vtkMarkerUtilities.h", "vtkPen.h", "vtkPolyDataItem.h", "vtkPropItem.h", "vtkTooltipItem.h", "vtkRenderingContext2DModule.h"], "licenses": []}, "VTK::RenderingFreeType": {"library_name": "vtkRenderingFreeType", "description": "", "enabled": true, "implementable": true, "third_party": false, "wrap_exclude": false, "kit": "VTK::Rendering", "depends": ["VTK::CommonCore", "VTK::CommonExecutionModel", "VTK::RenderingCore", "VTK::freetype"], "optional_depends": [], "private_depends": ["VTK::CommonDataModel", "VTK::FiltersGeneral", "VTK::utf8"], "implements": ["VTK::RenderingCore"], "headers": ["vtkFreeTypeStringToImage.h", "vtkFreeTypeTools.h", "vtkMathTextFreeTypeTextRenderer.h", "vtkMathTextUtilities.h", "vtkScaledTextActor.h", "vtkTextRendererStringToImage.h", "vtkVectorText.h", "vtkRenderingFreeTypeModule.h"], "licenses": []}, "VTK::freetype": {"library_name": "vtkfreetype", "description": "", "enabled": true, "implementable": false, "third_party": true, "wrap_exclude": false, "kit": null, "depends": ["VTK::kwiml", "VTK::zlib"], "optional_depends": [], "private_depends": [], "implements": [], "headers": [], "licenses": []}, "VTK::kwiml": {"library_name": "vtkkwiml", "description": "", "enabled": true, "implementable": false, "third_party": true, "wrap_exclude": false, "kit": null, "depends": [], "optional_depends": [], "private_depends": [], "implements": [], "headers": [], "licenses": []}, "VTK::RenderingCore": {"library_name": "vtkRenderingCore", "description": "", "enabled": true, "implementable": true, "third_party": false, "wrap_exclude": false, "kit": "VTK::Rendering", "depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::CommonExecutionModel", "VTK::CommonMath", "VTK::FiltersCore"], "optional_depends": [], "private_depends": ["VTK::CommonColor", "VTK::CommonComputationalGeometry", "VTK::CommonSystem", "VTK::CommonTransforms", "VTK::FiltersGeneral", "VTK::FiltersGeometry", "VTK::FiltersSources", "VTK::vtksys"], "implements": [], "headers": ["vtkGPUInfoListArray.h", "vtkPythagoreanQuadruples.h", "vtkRayCastStructures.h", "vtkRenderingCoreEnums.h", "vtkStateStorage.h", "vtkTDxConfigure.h", "vtkTDxMotionEventInfo.h", "vtkAbstractHyperTreeGridMapper.h", "vtkAbstractMapper.h", "vtkAbstractMapper3D.h", "vtkAbstractPicker.h", "vtkAbstractVolumeMapper.h", "vtkActor.h", "vtkActor2D.h", "vtkActor2DCollection.h", "vtkActorCollection.h", "vtkAssembly.h", "vtkAvatar.h", "vtkBackgroundColorMonitor.h", "vtkBillboardTextActor3D.h", "vtkCamera.h", "vtkCameraActor.h", "vtkCameraInterpolator.h", "vtkCellCenterDepthSort.h", "vtkCellGridMapper.h", "vtkColorTransferFunction.h", "vtkCompositeDataDisplayAttributes.h", "vtkCompositeDataDisplayAttributesLegacy.h", "vtkCompositePolyDataMapper.h", "vtkCompositePolyDataMapperDelegator.h", "vtkCoordinate.h", "vtkCuller.h", "vtkCullerCollection.h", "vtkDataSetMapper.h", "vtkDiscretizableColorTransferFunction.h", "vtkDistanceToCamera.h", "vtkFXAAOptions.h", "vtkFlagpoleLabel.h", "vtkFollower.h", "vtkFrameBufferObjectBase.h", "vtkFrustumCoverageCuller.h", "vtkGPUInfo.h", "vtkGPUInfoList.h", "vtkGenericVertexAttributeMapping.h", "vtkGlyph3DMapper.h", "vtkGraphMapper.h", "vtkGraphToGlyphs.h", "vtkGraphicsFactory.h", "vtkHardwarePicker.h", "vtkHardwareSelector.h", "vtkHardwareWindow.h", "vtkHierarchicalPolyDataMapper.h", "vtkImageActor.h", "vtkImageMapper.h", "vtkImageMapper3D.h", "vtkImageProperty.h", "vtkImageSlice.h", "vtkImageSliceMapper.h", "vtkInteractorEventRecorder.h", "vtkInteractorObserver.h", "vtkLabeledContourMapper.h", "vtkLight.h", "vtkLightActor.h", "vtkLightCollection.h", "vtkLightKit.h", "vtkLogLookupTable.h", "vtkLookupTableWithEnabling.h", "vtkMapArrayValues.h", "vtkMapper.h", "vtkMapper2D.h", "vtkMapperCollection.h", "vtkObserverMediator.h", "vtkPointGaussianMapper.h", "vtkPolyDataMapper.h", "vtkPolyDataMapper2D.h", "vtkProp.h", "vtkProp3D.h", "vtkProp3DCollection.h", "vtkProp3DFollower.h", "vtkPropAssembly.h", "vtkPropCollection.h", "vtkProperty.h", "vtkProperty2D.h", "vtkRenderPass.h", "vtkRenderState.h", "vtkRenderTimerLog.h", "vtkRenderWindow.h", "vtkRenderWindowCollection.h", "vtkRenderWindowInteractor.h", "vtkRenderWindowInteractor3D.h", "vtkRenderer.h", "vtkRendererCollection.h", "vtkRendererDelegate.h", "vtkRendererSource.h", "vtkResizingWindowToImageFilter.h", "vtkSelectVisiblePoints.h", "vtkShaderProperty.h", "vtkSkybox.h", "vtkStereoCompositor.h", "vtkTextActor.h", "vtkTextActor3D.h", "vtkTexture.h", "vtkTexturedActor2D.h", "vtkTransformCoordinateSystems.h", "vtkTransformInterpolator.h", "vtkTupleInterpolator.h", "vtkUniforms.h", "vtkViewDependentErrorMetric.h", "vtkViewport.h", "vtkVisibilitySort.h", "vtkVolume.h", "vtkVolumeCollection.h", "vtkVolumeProperty.h", "vtkWindowLevelLookupTable.h", "vtkWindowToImageFilter.h", "vtkAssemblyNode.h", "vtkAssemblyPath.h", "vtkAssemblyPaths.h", "vtkAreaPicker.h", "vtkPicker.h", "vtkAbstractPropPicker.h", "vtkLODProp3D.h", "vtkPropPicker.h", "vtkPickingManager.h", "vtkWorldPointPicker.h", "vtkCellPicker.h", "vtkPointPicker.h", "vtkRenderedAreaPicker.h", "vtkScenePicker.h", "vtkInteractorStyle.h", "vtkInteractorStyle3D.h", "vtkInteractorStyleSwitchBase.h", "vtkTDxInteractorStyle.h", "vtkTDxInteractorStyleCamera.h", "vtkTDxInteractorStyleSettings.h", "vtkStringToImage.h", "vtkTextMapper.h", "vtkTextProperty.h", "vtkTextPropertyCollection.h", "vtkTextRenderer.h", "vtkAbstractInteractionDevice.h", "vtkAbstractRenderDevice.h", "vtkRenderWidget.h", "vtkRenderingCoreModule.h"], "licenses": []}, "VTK::FiltersSources": {"library_name": "vtkFiltersSources", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Filters", "depends": ["VTK::CommonDataModel", "VTK::CommonExecutionModel"], "optional_depends": [], "private_depends": ["VTK::CommonComputationalGeometry", "VTK::CommonCore", "VTK::CommonTransforms", "VTK::FiltersCore", "VTK::FiltersGeneral"], "implements": [], "headers": ["vtkArcSource.h", "vtkArrowSource.h", "vtkButtonSource.h", "vtkCapsuleSource.h", "vtkCellTypeSource.h", "vtkConeSource.h", "vtkCubeSource.h", "vtkCylinderSource.h", "vtkDiagonalMatrixSource.h", "vtkDiskSource.h", "vtkEllipseArcSource.h", "vtkEllipticalButtonSource.h", "vtkFrustumSource.h", "vtkGlyphSource2D.h", "vtkGraphToPolyData.h", "vtkHandleSource.h", "vtkHyperTreeGridPreConfiguredSource.h", "vtkHyperTreeGridSource.h", "vtkLineSource.h", "vtkOutlineCornerFilter.h", "vtkOutlineCornerSource.h", "vtkOutlineSource.h", "vtkParametricFunctionSource.h", "vtkPartitionedDataSetSource.h", "vtkPartitionedDataSetCollectionSource.h", "vtkPlaneSource.h", "vtkPlatonicSolidSource.h", "vtkPointHandleSource.h", "vtkPointSource.h", "vtkPolyLineSource.h", "vtkPolyPointSource.h", "vtkProgrammableDataObjectSource.h", "vtkProgrammableSource.h", "vtkRandomHyperTreeGridSource.h", "vtkRectangularButtonSource.h", "vtkRegularPolygonSource.h", "vtkSelectionSource.h", "vtkSphereSource.h", "vtkSuperquadricSource.h", "vtkTessellatedBoxSource.h", "vtkTextSource.h", "vtkTexturedSphereSource.h", "vtkUniformHyperTreeGridSource.h", "vtkFiltersSourcesModule.h"], "licenses": []}, "VTK::ImagingCore": {"library_name": "vtkImagingCore", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Imaging", "depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::CommonExecutionModel"], "optional_depends": [], "private_depends": ["VTK::CommonMath", "VTK::CommonTransforms"], "implements": [], "headers": ["vtkAbstractImageInterpolator.h", "vtkExtractVOI.h", "vtkGenericImageInterpolator.h", "vtkImageAppendComponents.h", "vtkImageBlend.h", "vtkImageBSplineCoefficients.h", "vtkImageBSplineInternals.h", "vtkImageBSplineInterpolator.h", "vtkImageCacheFilter.h", "vtkImageCast.h", "vtkImageChangeInformation.h", "vtkImageClip.h", "vtkImageConstantPad.h", "vtkImageDataStreamer.h", "vtkImageDecomposeFilter.h", "vtkImageDifference.h", "vtkImageExtractComponents.h", "vtkImageFlip.h", "vtkImageInterpolator.h", "vtkImageIterateFilter.h", "vtkImageMagnify.h", "vtkImageMapToColors.h", "vtkImageMask.h", "vtkImageMirrorPad.h", "vtkImagePadFilter.h", "vtkImagePermute.h", "vtkImagePointDataIterator.h", "vtkImagePointIterator.h", "vtkImageProbeFilter.h", "vtkImageResample.h", "vtkImageResize.h", "vtkImageReslice.h", "vtkImageResliceToColors.h", "vtkImageShiftScale.h", "vtkImageShrink3D.h", "vtkImageSincInterpolator.h", "vtkImageStencilAlgorithm.h", "vtkImageStencilData.h", "vtkImageStencilIterator.h", "vtkImageStencilSource.h", "vtkImageThreshold.h", "vtkImageTranslateExtent.h", "vtkImageWrapPad.h", "vtkRTAnalyticSource.h", "vtkImagingCoreModule.h"], "licenses": []}, "VTK::FiltersGeneral": {"library_name": "vtkFiltersGeneral", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Filters", "depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::CommonExecutionModel", "VTK::CommonMisc", "VTK::FiltersCore"], "optional_depends": [], "private_depends": ["VTK::CommonComputationalGeometry", "VTK::CommonMath", "VTK::CommonSystem", "VTK::CommonTransforms", "VTK::FiltersGeometry", "VTK::FiltersVerdict", "VTK::fmt"], "implements": [], "headers": ["vtkAnimateModes.h", "vtkAnnotationLink.h", "vtkAppendLocationAttributes.h", "vtkAppendPoints.h", "vtkApproximatingSubdivisionFilter.h", "vtkAreaContourSpectrumFilter.h", "vtkAxes.h", "vtkBlankStructuredGrid.h", "vtkBlankStructuredGridWithImage.h", "vtkBlockIdScalars.h", "vtkBooleanOperationPolyDataFilter.h", "vtkBoxClipDataSet.h", "vtkBrownianPoints.h", "vtkCellDerivatives.h", "vtkCellValidator.h", "vtkCleanUnstructuredGrid.h", "vtkCleanUnstructuredGridCells.h", "vtkClipClosedSurface.h", "vtkClipConvexPolyData.h", "vtkClipDataSet.h", "vtkClipVolume.h", "vtkCoincidentPoints.h", "vtkContourTriangulator.h", "vtkCountFaces.h", "vtkCountVertices.h", "vtkCursor2D.h", "vtkCursor3D.h", "vtkCurvatures.h", "vtkDataSetGradient.h", "vtkDataSetGradientPrecompute.h", "vtkDataSetTriangleFilter.h", "vtkDateToNumeric.h", "vtkDeflectNormals.h", "vtkDeformPointSet.h", "vtkDensifyPolyData.h", "vtkDicer.h", "vtkDiscreteFlyingEdges2D.h", "vtkDiscreteFlyingEdges3D.h", "vtkDiscreteFlyingEdgesClipper2D.h", "vtkDiscreteMarchingCubes.h", "vtkDistancePolyDataFilter.h", "vtkEdgePoints.h", "vtkEqualizerFilter.h", "vtkExtractArray.h", "vtkExtractGhostCells.h", "vtkExtractSelectedFrustum.h", "vtkExtractSelectionBase.h", "vtkFiniteElementFieldDistributor.h", "vtkGradientFilter.h", "vtkGraphLayoutFilter.h", "vtkGraphToPoints.h", "vtkGraphWeightEuclideanDistanceFilter.h", "vtkGraphWeightFilter.h", "vtkGroupDataSetsFilter.h", "vtkGroupTimeStepsFilter.h", "vtkHierarchicalDataLevelFilter.h", "vtkHyperStreamline.h", "vtkIconGlyphFilter.h", "vtkImageDataToPointSet.h", "vtkImageMarchingCubes.h", "vtkInterpolateDataSetAttributes.h", "vtkInterpolatingSubdivisionFilter.h", "vtkIntersectionPolyDataFilter.h", "vtkJoinTables.h", "vtkLevelIdScalars.h", "vtkLinkEdgels.h", "vtkLoopBooleanPolyDataFilter.h", "vtkMarchingContourFilter.h", "vtkMatricizeArray.h", "vtkMergeArrays.h", "vtkMergeCells.h", "vtkMergeTimeFilter.h", "vtkMergeVectorComponents.h", "vtkMultiBlockDataGroupFilter.h", "vtkMultiBlockMergeFilter.h", "vtkMultiThreshold.h", "vtkNormalizeMatrixVectors.h", "vtkOBBDicer.h", "vtkOBBTree.h", "vtkOverlappingAMRLevelIdScalars.h", "vtkPassArrays.h", "vtkPassSelectedArrays.h", "vtkPointConnectivityFilter.h", "vtkPolyDataStreamer.h", "vtkPolyDataToReebGraphFilter.h", "vtkProbePolyhedron.h", "vtkQuadraturePointInterpolator.h", "vtkQuadraturePointsGenerator.h", "vtkQuadratureSchemeDictionaryGenerator.h", "vtkQuantizePolyDataPoints.h", "vtkRandomAttributeGenerator.h", "vtkRectilinearGridClip.h", "vtkRectilinearGridToPointSet.h", "vtkRectilinearGridToTetrahedra.h", "vtkRecursiveDividingCubes.h", "vtkReflectionFilter.h", "vtkRemovePolyData.h", "vtkRotationFilter.h", "vtkSampleImplicitFunctionFilter.h", "vtkShrinkFilter.h", "vtkShrinkPolyData.h", "vtkSpatialRepresentationFilter.h", "vtkSphericalHarmonics.h", "vtkSplineFilter.h", "vtkSplitByCellScalarFilter.h", "vtkSplitColumnComponents.h", "vtkSplitField.h", "vtkStructuredGridClip.h", "vtkSubPixelPositionEdgels.h", "vtkSubdivisionFilter.h", "vtkSynchronizeTimeFilter.h", "vtkTableBasedClipDataSet.h", "vtkTableFFT.h", "vtkTableToPolyData.h", "vtkTableToStructuredGrid.h", "vtkTemporalPathLineFilter.h", "vtkTemporalStatistics.h", "vtkTessellatorFilter.h", "vtkTimeSourceExample.h", "vtkTransformFilter.h", "vtkTransformPolyDataFilter.h", "vtkUncertaintyTubeFilter.h", "vtkVertexGlyphFilter.h", "vtkVolumeContourSpectrumFilter.h", "vtkVoxelContoursToSurfaceFilter.h", "vtkWarpLens.h", "vtkWarpScalar.h", "vtkWarpTo.h", "vtkWarpVector.h", "vtkYoungsMaterialInterface.h", "vtkFiltersGeneralModule.h"], "licenses": []}, "VTK::FiltersVerdict": {"library_name": "vtkFiltersVerdict", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Filters", "depends": ["VTK::CommonExecutionModel"], "optional_depends": [], "private_depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::FiltersCore", "VTK::FiltersGeometry", "VTK::verdict"], "implements": [], "headers": ["vtkBoundaryMeshQuality.h", "vtkCellQuality.h", "vtkCellSizeFilter.h", "vtkMatrixMathFilter.h", "vtkMeshQuality.h", "vtkFiltersVerdictModule.h"], "licenses": []}, "VTK::verdict": {"library_name": "vtkverdict", "description": "", "enabled": true, "implementable": false, "third_party": true, "wrap_exclude": false, "kit": null, "depends": [], "optional_depends": [], "private_depends": [], "implements": [], "headers": ["vtkverdict/verdict.h", "vtkverdict/VerdictVector.hpp", "vtkverdict/verdict_defines.hpp"], "licenses": []}, "VTK::FiltersGeometry": {"library_name": "vtkFiltersGeometry", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Filters", "depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::CommonExecutionModel"], "optional_depends": [], "private_depends": ["VTK::FiltersCore", "VTK::vtksys"], "implements": [], "headers": ["vtkAbstractGridConnectivity.h", "vtkAttributeSmoothingFilter.h", "vtkCompositeDataGeometryFilter.h", "vtkDataSetRegionSurfaceFilter.h", "vtkDataSetSurfaceFilter.h", "vtkExplicitStructuredGridSurfaceFilter.h", "vtkGeometryFilter.h", "vtkHierarchicalDataSetGeometryFilter.h", "vtkImageDataGeometryFilter.h", "vtkImageDataToUniformGrid.h", "vtkLinearToQuadraticCellsFilter.h", "vtkMarkBoundaryFilter.h", "vtkProjectSphereFilter.h", "vtkRecoverGeometryWireframe.h", "vtkRectilinearGridGeometryFilter.h", "vtkRectilinearGridPartitioner.h", "vtkStructuredAMRGridConnectivity.h", "vtkStructuredAMRNeighbor.h", "vtkStructuredGridConnectivity.h", "vtkStructuredGridGeometryFilter.h", "vtkStructuredGridPartitioner.h", "vtkStructuredNeighbor.h", "vtkStructuredPointsGeometryFilter.h", "vtkUnstructuredGridGeometryFilter.h", "vtkFiltersGeometryModule.h"], "licenses": []}, "VTK::CommonComputationalGeometry": {"library_name": "vtkCommonComputationalGeometry", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Common", "depends": ["VTK::CommonCore", "VTK::CommonDataModel"], "optional_depends": [], "private_depends": [], "implements": [], "headers": ["vtkBilinearQuadIntersection.h", "vtkCardinalSpline.h", "vtkKochanekSpline.h", "vtkParametricBohemianDome.h", "vtkParametricBour.h", "vtkParametricBoy.h", "vtkParametricCatalanMinimal.h", "vtkParametricConicSpiral.h", "vtkParametricCrossCap.h", "vtkParametricDini.h", "vtkParametricEllipsoid.h", "vtkParametricEnneper.h", "vtkParametricFigure8Klein.h", "vtkParametricFunction.h", "vtkParametricHenneberg.h", "vtkParametricKlein.h", "vtkParametricKuen.h", "vtkParametricMobius.h", "vtkParametricPluckerConoid.h", "vtkParametricPseudosphere.h", "vtkParametricRandomHills.h", "vtkParametricRoman.h", "vtkParametricSpline.h", "vtkParametricSuperEllipsoid.h", "vtkParametricSuperToroid.h", "vtkParametricTorus.h", "vtkCommonComputationalGeometryModule.h"], "licenses": []}, "VTK::FiltersCore": {"library_name": "vtkFiltersCore", "description": "", "enabled": true, "implementable": true, "third_party": false, "wrap_exclude": false, "kit": "VTK::Filters", "depends": ["VTK::CommonCore", "VTK::CommonDataModel", "VTK::CommonExecutionModel", "VTK::CommonMisc"], "optional_depends": [], "private_depends": ["VTK::CommonMath", "VTK::CommonSystem", "VTK::CommonTransforms", "VTK::vtksys"], "implements": [], "headers": ["vtk3DLinearGridCrinkleExtractor.h", "vtk3DLinearGridPlaneCutter.h", "vtkAppendArcLength.h", "vtkAppendCompositeDataLeaves.h", "vtkAppendDataSets.h", "vtkAppendFilter.h", "vtkAppendPolyData.h", "vtkAppendSelection.h", "vtkArrayCalculator.h", "vtkArrayRename.h", "vtkAssignAttribute.h", "vtkAttributeDataToFieldDataFilter.h", "vtkAttributeDataToTableFilter.h", "vtkBinCellDataFilter.h", "vtkBinnedDecimation.h", "vtkCellCenters.h", "vtkCellDataToPointData.h", "vtkCenterOfMass.h", "vtkCleanPolyData.h", "vtkClipPolyData.h", "vtkCompositeCutter.h", "vtkCompositeDataProbeFilter.h", "vtkConnectivityFilter.h", "vtkConstrainedSmoothingFilter.h", "vtkContour3DLinearGrid.h", "vtkContourFilter.h", "vtkContourGrid.h", "vtkContourHelper.h", "vtkConvertToMultiBlockDataSet.h", "vtkConvertToPartitionedDataSetCollection.h", "vtkConvertToPolyhedra.h", "vtkCutter.h", "vtkDataObjectGenerator.h", "vtkDataObjectToDataSetFilter.h", "vtkDataSetEdgeSubdivisionCriterion.h", "vtkDataSetToDataObjectFilter.h", "vtkDecimatePolylineFilter.h", "vtkDecimatePro.h", "vtkDelaunay2D.h", "vtkDelaunay3D.h", "vtkEdgeSubdivisionCriterion.h", "vtkElevationFilter.h", "vtkExecutionTimer.h", "vtkExplicitStructuredGridCrop.h", "vtkExplicitStructuredGridToUnstructuredGrid.h", "vtkExtractCells.h", "vtkExtractCellsAlongPolyLine.h", "vtkExtractEdges.h", "vtkFeatureEdges.h", "vtkFieldDataToAttributeDataFilter.h", "vtkFieldDataToDataSetAttribute.h", "vtkFlyingEdges2D.h", "vtkFlyingEdges3D.h", "vtkFlyingEdgesPlaneCutter.h", "vtkGlyph2D.h", "vtkGlyph3D.h", "vtkGridSynchronizedTemplates3D.h", "vtkHedgeHog.h", "vtkHull.h", "vtkHyperTreeGridProbeFilter.h", "vtkIdFilter.h", "vtkImageAppend.h", "vtkImageDataToExplicitStructuredGrid.h", "vtkImplicitPolyDataDistance.h", "vtkImplicitProjectOnPlaneDistance.h", "vtkMarchingCubes.h", "vtkMarchingSquares.h", "vtkMaskFields.h", "vtkMaskPoints.h", "vtkMaskPolyData.h", "vtkMassProperties.h", "vtkMergeDataObjectFilter.h", "vtkMergeFields.h", "vtkMergeFilter.h", "vtkMoleculeAppend.h", "vtkMultiObjectMassProperties.h", "vtkPackLabels.h", "vtkPassThrough.h", "vtkPlaneCutter.h", "vtkPointDataToCellData.h", "vtkPolyDataConnectivityFilter.h", "vtkPolyDataEdgeConnectivityFilter.h", "vtkPolyDataNormals.h", "vtkPolyDataPlaneClipper.h", "vtkPolyDataPlaneCutter.h", "vtkPolyDataTangents.h", "vtkPolyDataToUnstructuredGrid.h", "vtkProbeFilter.h", "vtkQuadricClustering.h", "vtkQuadricDecimation.h", "vtkRearrangeFields.h", "vtkRectilinearSynchronizedTemplates.h", "vtkRemoveDuplicatePolys.h", "vtkRemoveUnusedPoints.h", "vtkResampleToImage.h", "vtkResampleWithDataSet.h", "vtkReverseSense.h", "vtkSimpleElevationFilter.h", "vtkSmoothPolyDataFilter.h", "vtkSphereTreeFilter.h", "vtkStructuredDataPlaneCutter.h", "vtkStaticCleanPolyData.h", "vtkStaticCleanUnstructuredGrid.h", "vtkStreamerBase.h", "vtkStreamingTessellator.h", "vtkStripper.h", "vtkStructuredGridAppend.h", "vtkStructuredGridOutlineFilter.h", "vtkSurfaceNets2D.h", "vtkSurfaceNets3D.h", "vtkSynchronizedTemplates2D.h", "vtkSynchronizedTemplates3D.h", "vtkSynchronizedTemplatesCutter3D.h", "vtkTensorGlyph.h", "vtkThreshold.h", "vtkThresholdPoints.h", "vtkTransposeTable.h", "vtkTriangleFilter.h", "vtkTriangleMeshPointNormals.h", "vtkTubeBender.h", "vtkTubeFilter.h", "vtkUnstructuredGridQuadricDecimation.h", "vtkUnstructuredGridToExplicitStructuredGrid.h", "vtkVectorDot.h", "vtkVectorNorm.h", "vtkVoronoi2D.h", "vtkWindowedSincPolyDataFilter.h", "vtkFiltersCoreModule.h"], "licenses": []}, "VTK::CommonExecutionModel": {"library_name": "vtkCommonExecutionModel", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Common", "depends": ["VTK::CommonCore", "VTK::CommonDataModel"], "optional_depends": [], "private_depends": ["VTK::CommonMisc", "VTK::CommonSystem"], "implements": [], "headers": ["vtkAlgorithm.h", "vtkAlgorithmOutput.h", "vtkAnnotationLayersAlgorithm.h", "vtkArrayDataAlgorithm.h", "vtkCachedStreamingDemandDrivenPipeline.h", "vtkCastToConcrete.h", "vtkCellGridAlgorithm.h", "vtkCompositeDataPipeline.h", "vtkCompositeDataSetAlgorithm.h", "vtkDataObjectAlgorithm.h", "vtkDataSetAlgorithm.h", "vtkDemandDrivenPipeline.h", "vtkDirectedGraphAlgorithm.h", "vtkEnsembleSource.h", "vtkExecutive.h", "vtkExplicitStructuredGridAlgorithm.h", "vtkExtentRCBPartitioner.h", "vtkExtentSplitter.h", "vtkExtentTranslator.h", "vtkFilteringInformationKeyManager.h", "vtkGraphAlgorithm.h", "vtkHierarchicalBoxDataSetAlgorithm.h", "vtkHyperTreeGridAlgorithm.h", "vtkImageAlgorithm.h", "vtkImageInPlaceFilter.h", "vtkImageProgressIterator.h", "vtkImageToStructuredGrid.h", "vtkImageToStructuredPoints.h", "vtkInformationDataObjectMetaDataKey.h", "vtkInformationExecutivePortKey.h", "vtkInformationExecutivePortVectorKey.h", "vtkInformationIntegerRequestKey.h", "vtkMoleculeAlgorithm.h", "vtkMultiBlockDataSetAlgorithm.h", "vtkMultiTimeStepAlgorithm.h", "vtkParallelReader.h", "vtkPartitionedDataSetAlgorithm.h", "vtkPartitionedDataSetCollectionAlgorithm.h", "vtkPassInputTypeAlgorithm.h", "vtkPiecewiseFunctionAlgorithm.h", "vtkPiecewiseFunctionShiftScale.h", "vtkPointSetAlgorithm.h", "vtkPolyDataAlgorithm.h", "vtkProgressObserver.h", "vtkReaderAlgorithm.h", "vtkRectilinearGridAlgorithm.h", "vtkSMPProgressObserver.h", "vtkScalarTree.h", "vtkSelectionAlgorithm.h", "vtkSimpleImageToImageFilter.h", "vtkSimpleReader.h", "vtkSimpleScalarTree.h", "vtkSpanSpace.h", "vtkSphereTree.h", "vtkStreamingDemandDrivenPipeline.h", "vtkStructuredGridAlgorithm.h", "vtkTableAlgorithm.h", "vtkThreadedCompositeDataPipeline.h", "vtkThreadedImageAlgorithm.h", "vtkTreeAlgorithm.h", "vtkTrivialConsumer.h", "vtkTrivialProducer.h", "vtkUndirectedGraphAlgorithm.h", "vtkUniformGridPartitioner.h", "vtkUnstructuredGridAlgorithm.h", "vtkUnstructuredGridBaseAlgorithm.h", "vtkNonOverlappingAMRAlgorithm.h", "vtkOverlappingAMRAlgorithm.h", "vtkUniformGridAMRAlgorithm.h", "vtkCommonExecutionModelModule.h"], "licenses": []}, "VTK::CommonDataModel": {"library_name": "vtkCommonDataModel", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Common", "depends": ["VTK::CommonCore", "VTK::CommonMath", "VTK::CommonTransforms"], "optional_depends": [], "private_depends": ["VTK::CommonMisc", "VTK::CommonSystem", "VTK::pugixml", "VTK::vtksys"], "implements": [], "headers": ["vtkCellGridQuery.h", "vtkCellGridResponder.h", "vtkCellGridResponderBase.h", "vtkCellType.h", "vtkColor.h", "vtkDataAssemblyVisitor.h", "vtkDataObjectTreeInternals.h", "vtkHyperTreeGridScales.h", "vtkHyperTreeGridTools.h", "vtkIntersectionCounter.h", "vtkLabelMapLookup.h", "vtkRect.h", "vtkVector.h", "vtkVectorOperators.h", "vtkAMRBox.h", "vtkAMRUtilities.h", "vtkAbstractCellLinks.h", "vtkAbstractCellLocator.h", "vtkAbstractElectronicData.h", "vtkAbstractPointLocator.h", "vtkAdjacentVertexIterator.h", "vtkAnimationScene.h", "vtkAnnotation.h", "vtkAnnotationLayers.h", "vtkArrayData.h", "vtkAtom.h", "vtkAttributesErrorMetric.h", "vtkBSPCuts.h", "vtkBSPIntersections.h", "vtkBezierCurve.h", "vtkBezierHexahedron.h", "vtkBezierInterpolation.h", "vtkBezierQuadrilateral.h", "vtkBezierTetra.h", "vtkBezierTriangle.h", "vtkBezierWedge.h", "vtkBiQuadraticQuad.h", "vtkBiQuadraticQuadraticHexahedron.h", "vtkBiQuadraticQuadraticWedge.h", "vtkBiQuadraticTriangle.h", "vtkBond.h", "vtkBoundingBox.h", "vtkBox.h", "vtkCell.h", "vtkCell3D.h", "vtkCellArray.h", "vtkCellArrayIterator.h", "vtkCellAttribute.h", "vtkCellData.h", "vtkCellGrid.h", "vtkCellGridBoundsQuery.h", "vtkCellGridResponders.h", "vtkCellGridSidesQuery.h", "vtkCellIterator.h", "vtkCellLinks.h", "vtkCellLocator.h", "vtkCellLocatorStrategy.h", "vtkCellMetadata.h", "vtkCellTreeLocator.h", "vtkCellTypes.h", "vtkClosestNPointsStrategy.h", "vtkClosestPointStrategy.h", "vtkCompositeDataIterator.h", "vtkCompositeDataSet.h", "vtkCone.h", "vtkConvexPointSet.h", "vtkCoordinateFrame.h", "vtkCubicLine.h", "vtkCylinder.h", "vtkDataAssembly.h", "vtkDataAssemblyUtilities.h", "vtkDataObject.h", "vtkDataObjectCollection.h", "vtkDataObjectTree.h", "vtkDataObjectTreeIterator.h", "vtkDataObjectTypes.h", "vtkDataSet.h", "vtkDataSetAttributes.h", "vtkDataSetAttributesFieldList.h", "vtkDataSetCellIterator.h", "vtkDataSetCollection.h", "vtkDirectedAcyclicGraph.h", "vtkDirectedGraph.h", "vtkDistributedGraphHelper.h", "vtkEdgeListIterator.h", "vtkEdgeTable.h", "vtkEmptyCell.h", "vtkExplicitStructuredGrid.h", "vtkExtractStructuredGridHelper.h", "vtkFieldData.h", "vtkFindCellStrategy.h", "vtkGenericAdaptorCell.h", "vtkGenericAttribute.h", "vtkGenericAttributeCollection.h", "vtkGenericCell.h", "vtkGenericCellIterator.h", "vtkGenericCellTessellator.h", "vtkGenericDataSet.h", "vtkGenericEdgeTable.h", "vtkGenericInterpolatedVelocityField.h", "vtkGenericPointIterator.h", "vtkGenericSubdivisionErrorMetric.h", "vtkGeometricErrorMetric.h", "vtkGraph.h", "vtkGraphEdge.h", "vtkGraphInternals.h", "vtkHexagonalPrism.h", "vtkHexahedron.h", "vtkHierarchicalBoxDataIterator.h", "vtkHierarchicalBoxDataSet.h", "vtkHigherOrderCurve.h", "vtkHigherOrderHexahedron.h", "vtkHigherOrderInterpolation.h", "vtkHigherOrderQuadrilateral.h", "vtkHigherOrderTetra.h", "vtkHigherOrderTriangle.h", "vtkHigherOrderWedge.h", "vtkHyperTree.h", "vtkHyperTreeCursor.h", "vtkHyperTreeGrid.h", "vtkHyperTreeGridLocator.h", "vtkHyperTreeGridGeometricLocator.h", "vtkHyperTreeGridNonOrientedCursor.h", "vtkHyperTreeGridNonOrientedGeometryCursor.h", "vtkHyperTreeGridNonOrientedUnlimitedGeometryCursor.h", "vtkHyperTreeGridNonOrientedMooreSuperCursor.h", "vtkHyperTreeGridNonOrientedMooreSuperCursorLight.h", "vtkHyperTreeGridNonOrientedUnlimitedMooreSuperCursor.h", "vtkHyperTreeGridNonOrientedSuperCursor.h", "vtkHyperTreeGridNonOrientedSuperCursorLight.h", "vtkHyperTreeGridNonOrientedUnlimitedSuperCursor.h", "vtkHyperTreeGridNonOrientedVonNeumannSuperCursor.h", "vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight.h", "vtkHyperTreeGridOrientedCursor.h", "vtkHyperTreeGridOrientedGeometryCursor.h", "vtkImageData.h", "vtkImageIterator.h", "vtkImageTransform.h", "vtkImplicitBoolean.h", "vtkImplicitDataSet.h", "vtkImplicitFunction.h", "vtkImplicitFunctionCollection.h", "vtkImplicitHalo.h", "vtkImplicitSelectionLoop.h", "vtkImplicitSum.h", "vtkImplicitVolume.h", "vtkImplicitWindowFunction.h", "vtkInEdgeIterator.h", "vtkIncrementalOctreeNode.h", "vtkIncrementalOctreePointLocator.h", "vtkIncrementalPointLocator.h", "vtkInformationQuadratureSchemeDefinitionVectorKey.h", "vtkIterativeClosestPointTransform.h", "vtkKdNode.h", "vtkKdTree.h", "vtkKdTreePointLocator.h", "vtkLagrangeCurve.h", "vtkLagrangeHexahedron.h", "vtkLagrangeInterpolation.h", "vtkLagrangeQuadrilateral.h", "vtkLagrangeTetra.h", "vtkLagrangeTriangle.h", "vtkLagrangeWedge.h", "vtkLine.h", "vtkLocator.h", "vtkMarchingCubesTriangleCases.h", "vtkMarchingCubesPolygonCases.h", "vtkMarchingSquaresLineCases.h", "vtkMeanValueCoordinatesInterpolator.h", "vtkMergePoints.h", "vtkMolecule.h", "vtkMultiBlockDataSet.h", "vtkMultiPieceDataSet.h", "vtkMutableDirectedGraph.h", "vtkMutableUndirectedGraph.h", "vtkNonLinearCell.h", "vtkNonMergingPointLocator.h", "vtkOctreePointLocator.h", "vtkOctreePointLocatorNode.h", "vtkOrderedTriangulator.h", "vtkOutEdgeIterator.h", "vtkPartitionedDataSet.h", "vtkPartitionedDataSetCollection.h", "vtkPath.h", "vtkPentagonalPrism.h", "vtkPerlinNoise.h", "vtkPiecewiseFunction.h", "vtkPixel.h", "vtkPixelExtent.h", "vtkPixelTransfer.h", "vtkPlane.h", "vtkPlaneCollection.h", "vtkPlanes.h", "vtkPlanesIntersection.h", "vtkPointData.h", "vtkPointLocator.h", "vtkPointSet.h", "vtkPointSetCellIterator.h", "vtkPointsProjectedHull.h", "vtkPolyData.h", "vtkPolyDataCollection.h", "vtkPolyLine.h", "vtkPolyPlane.h", "vtkPolyVertex.h", "vtkPolygon.h", "vtkPolyhedron.h", "vtkPolyhedronUtilities.h", "vtkPyramid.h", "vtkQuad.h", "vtkQuadraticEdge.h", "vtkQuadraticHexahedron.h", "vtkQuadraticLinearQuad.h", "vtkQuadraticLinearWedge.h", "vtkQuadraticPolygon.h", "vtkQuadraticPyramid.h", "vtkQuadraticQuad.h", "vtkQuadraticTetra.h", "vtkQuadraticTriangle.h", "vtkQuadraticWedge.h", "vtkQuadratureSchemeDefinition.h", "vtkQuadric.h", "vtkRectilinearGrid.h", "vtkReebGraph.h", "vtkReebGraphSimplificationMetric.h", "vtkSelection.h", "vtkSelectionNode.h", "vtkSimpleCellTessellator.h", "vtkSmoothErrorMetric.h", "vtkSortFieldData.h", "vtkSphere.h", "vtkSpheres.h", "vtkSphericalPointIterator.h", "vtkSpline.h", "vtkStaticCellLinks.h", "vtkStaticCellLocator.h", "vtkStaticPointLocator.h", "vtkStaticPointLocator2D.h", "vtkStructuredData.h", "vtkStructuredExtent.h", "vtkStructuredGrid.h", "vtkStructuredPoints.h", "vtkStructuredPointsCollection.h", "vtkSuperquadric.h", "vtkTable.h", "vtkTetra.h", "vtkTree.h", "vtkTreeBFSIterator.h", "vtkTreeDFSIterator.h", "vtkTreeIterator.h", "vtkTriQuadraticHexahedron.h", "vtkTriQuadraticPyramid.h", "vtkTriangle.h", "vtkTriangleStrip.h", "vtkUndirectedGraph.h", "vtkUniformGrid.h", "vtkUniformHyperTreeGrid.h", "vtkUnstructuredGrid.h", "vtkUnstructuredGridBase.h", "vtkUnstructuredGridCellIterator.h", "vtkVertex.h", "vtkVertexListIterator.h", "vtkVoxel.h", "vtkWedge.h", "vtkXMLDataElement.h", "vtkAMRDataInternals.h", "vtkAMRInformation.h", "vtkNonOverlappingAMR.h", "vtkOverlappingAMR.h", "vtkUniformGridAMR.h", "vtkUniformGridAMRDataIterator.h", "vtkAngularPeriodicDataArray.h", "vtkArrayListTemplate.h", "vtkMappedUnstructuredGrid.h", "vtkMappedUnstructuredGridCellIterator.h", "vtkPeriodicDataArray.h", "vtkStaticCellLinksTemplate.h", "vtkStaticEdgeLocatorTemplate.h", "vtkStaticFaceHashLinksTemplate.h", "vtkCommonDataModelModule.h"], "licenses": []}, "VTK::CommonSystem": {"library_name": "vtkCommonSystem", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Common", "depends": ["VTK::CommonCore"], "optional_depends": [], "private_depends": ["VTK::vtksys"], "implements": [], "headers": ["vtkClientSocket.h", "vtkDirectory.h", "vtkExecutableRunner.h", "vtkServerSocket.h", "vtkSocket.h", "vtkSocketCollection.h", "vtkTimerLog.h", "vtkCommonSystemModule.h"], "licenses": []}, "VTK::CommonMisc": {"library_name": "vtkCommonMisc", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Common", "depends": ["VTK::CommonCore", "VTK::CommonMath"], "optional_depends": [], "private_depends": ["VTK::vtksys", "VTK::exprtk"], "implements": [], "headers": ["vtkContourValues.h", "vtkErrorCode.h", "vtkExprTkFunctionParser.h", "vtkFunctionParser.h", "vtkHeap.h", "vtkPolygonBuilder.h", "vtkResourceFileLocator.h", "vtkCommonMiscModule.h"], "licenses": []}, "VTK::exprtk": {"library_name": "vtkexprtk", "description": "", "enabled": true, "implementable": false, "third_party": true, "wrap_exclude": false, "kit": null, "depends": [], "optional_depends": [], "private_depends": [], "implements": [], "headers": [], "licenses": []}, "VTK::CommonTransforms": {"library_name": "vtkCommonTransforms", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Common", "depends": ["VTK::CommonCore", "VTK::CommonMath"], "optional_depends": [], "private_depends": ["VTK::vtksys"], "implements": [], "headers": ["vtkAbstractTransform.h", "vtkCylindricalTransform.h", "vtkGeneralTransform.h", "vtkHomogeneousTransform.h", "vtkIdentityTransform.h", "vtkLandmarkTransform.h", "vtkLinearTransform.h", "vtkMatrixToHomogeneousTransform.h", "vtkMatrixToLinearTransform.h", "vtkPerspectiveTransform.h", "vtkSphericalTransform.h", "vtkThinPlateSplineTransform.h", "vtkTransform.h", "vtkTransform2D.h", "vtkTransformCollection.h", "vtkWarpTransform.h", "vtkCommonTransformsModule.h"], "licenses": []}, "VTK::CommonMath": {"library_name": "vtkCommonMath", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Common", "depends": ["VTK::CommonCore", "VTK::kissfft"], "optional_depends": [], "private_depends": [], "implements": [], "headers": ["vtkTuple.h", "vtkAmoebaMinimizer.h", "vtkFFT.h", "vtkFunctionSet.h", "vtkInitialValueProblemSolver.h", "vtkMatrix3x3.h", "vtkMatrix4x4.h", "vtkPolynomialSolversUnivariate.h", "vtkQuaternionInterpolator.h", "vtkRungeKutta2.h", "vtkRungeKutta4.h", "vtkRungeKutta45.h", "vtkQuaternion.h", "vtkCommonMathModule.h"], "licenses": []}, "VTK::kissfft": {"library_name": "vtkkissfft", "description": "", "enabled": true, "implementable": false, "third_party": true, "wrap_exclude": false, "kit": null, "depends": [], "optional_depends": [], "private_depends": [], "implements": [], "headers": ["vtkkissfft/kiss_fft_exports.h", "vtkkissfft/_kiss_fft_guts.h", "vtkkissfft/kiss_fft.h", "vtkkissfft/tools/kfc.h", "vtkkissfft/tools/kiss_fftnd.h", "vtkkissfft/tools/kiss_fftndr.h", "vtkkissfft/tools/kiss_fftr.h", "vtkkissfft/tools/vtkkissfft_fftnd.h", "vtkkissfft/tools/vtkkissfft_fftndr.h", "vtkkissfft/tools/vtkkissfft_fftr.h", "vtkkissfft/vtkkissfft_fft.h", "vtkkissfft/vtk_kiss_fft_mangle.h"], "licenses": []}, "VTK::CommonCore": {"library_name": "vtkCommonCore", "description": "", "enabled": true, "implementable": false, "third_party": false, "wrap_exclude": false, "kit": "VTK::Common", "depends": ["VTK::kwiml", "VTK::vtksys"], "optional_depends": ["VTK::loguru"], "private_depends": ["VTK::utf8", "VTK::fast_float"], "implements": [], "headers": ["vtkABI.h", "vtkArrayIteratorIncludes.h", "vtkAssume.h", "vtkAutoInit.h", "vtkBuffer.h", "vtkCompiler.h", "vtkDataArrayIteratorMacro.h", "vtkDataArrayMeta.h", "vtkDataArrayRange.h", "vtkDeprecation.h", "vtkEventData.h", "vtkGenericDataArrayLookupHelper.h", "vtkIOStream.h", "vtkIOStreamFwd.h", "vtkInformationInternals.h", "vtkMathUtilities.h", "vtkMatrixUtilities.h", "vtkMeta.h", "vtkNew.h", "vtkRange.h", "vtkRangeIterableTraits.h", "vtkSetGet.h", "vtkSmartPointer.h", "vtkSystemIncludes.h", "vtkTemplateAliasMacro.h", "vtkTestDataArray.h", "vtkType.h", "vtkTypeTraits.h", "vtkTypedDataArrayIterator.h", "vtkValueFromString.h", "vtkVariantCast.h", "vtkVariantCreate.h", "vtkVariantExtract.h", "vtkVariantInlineOperators.h", "vtkWeakPointer.h", "vtkWin32Header.h", "vtkWindows.h", "vtkWrappingHints.h", "vtkSMPTools.h", "vtkSMPThreadLocal.h", "vtkSMPThreadLocalObject.h", "vtkABINamespace.h", "vtkArrayDispatchArrayList.h", "vtkMathConfigure.h", "vtkTypeListMacros.h", "vtkVTK_USE_SCALED_SOA_ARRAYS.h", "vtkBuild.h", "vtkDebug.h", "vtkDebugRangeIterators.h", "vtkEndian.h", "vtkFeatures.h", "vtkLegacy.h", "vtkOptions.h", "vtkPlatform.h", "vtkSMP.h", "vtkThreads.h", "vtkVersionFull.h", "vtkVersionMacros.h", "vtkTypeInt8Array.h", "vtkTypeInt16Array.h", "vtkTypeInt32Array.h", "vtkTypeInt64Array.h", "vtkTypeUInt8Array.h", "vtkTypeUInt16Array.h", "vtkTypeUInt32Array.h", "vtkTypeUInt64Array.h", "vtkTypeFloat32Array.h", "vtkTypeFloat64Array.h", "vtkCxxABIConfigure.h", "vtkAbstractArray.h", "vtkAnimationCue.h", "vtkArchiver.h", "vtkArray.h", "vtkArrayCoordinates.h", "vtkArrayExtents.h", "vtkArrayExtentsList.h", "vtkArrayIterator.h", "vtkArrayRange.h", "vtkArraySort.h", "vtkArrayWeights.h", "vtkAtomicMutex.h", "vtkBitArray.h", "vtkBitArrayIterator.h", "vtkBoxMuellerRandomSequence.h", "vtkBreakPoint.h", "vtkByteSwap.h", "vtkCallbackCommand.h", "vtkCharArray.h", "vtkCollection.h", "vtkCollectionIterator.h", "vtkCommand.h", "vtkCommonInformationKeyManager.h", "vtkDataArray.h", "vtkDataArrayCollection.h", "vtkDataArrayCollectionIterator.h", "vtkDataArraySelection.h", "vtkDebugLeaks.h", "vtkDebugLeaksManager.h", "vtkDoubleArray.h", "vtkDynamicLoader.h", "vtkEventForwarderCommand.h", "vtkFileOutputWindow.h", "vtkFloatArray.h", "vtkFloatingPointExceptions.h", "vtkGarbageCollector.h", "vtkGarbageCollectorManager.h", "vtkGaussianRandomSequence.h", "vtkIdList.h", "vtkIdListCollection.h", "vtkIdTypeArray.h", "vtkIndent.h", "vtkInformation.h", "vtkInformationDataObjectKey.h", "vtkInformationDoubleKey.h", "vtkInformationDoubleVectorKey.h", "vtkInformationIdTypeKey.h", "vtkInformationInformationKey.h", "vtkInformationInformationVectorKey.h", "vtkInformationIntegerKey.h", "vtkInformationIntegerPointerKey.h", "vtkInformationIntegerVectorKey.h", "vtkInformationIterator.h", "vtkInformationKey.h", "vtkInformationKeyLookup.h", "vtkInformationKeyVectorKey.h", "vtkInformationObjectBaseKey.h", "vtkInformationObjectBaseVectorKey.h", "vtkInformationRequestKey.h", "vtkInformationStringKey.h", "vtkInformationStringVectorKey.h", "vtkInformationUnsignedLongKey.h", "vtkInformationVariantKey.h", "vtkInformationVariantVectorKey.h", "vtkInformationVector.h", "vtkIntArray.h", "vtkLargeInteger.h", "vtkLogger.h", "vtkLongArray.h", "vtkLongLongArray.h", "vtkLookupTable.h", "vtkMath.h", "vtkMersenneTwister.h", "vtkMinimalStandardRandomSequence.h", "vtkMultiThreader.h", "vtkOStrStreamWrapper.h", "vtkOStreamWrapper.h", "vtkObject.h", "vtkObjectBase.h", "vtkObjectFactory.h", "vtkObjectFactoryCollection.h", "vtkOldStyleCallbackCommand.h", "vtkOutputWindow.h", "vtkOverrideInformation.h", "vtkOverrideInformationCollection.h", "vtkPoints.h", "vtkPoints2D.h", "vtkPriorityQueue.h", "vtkRandomPool.h", "vtkRandomSequence.h", "vtkReferenceCount.h", "vtkScalarsToColors.h", "vtkShortArray.h", "vtkSignedCharArray.h", "vtkSmartPointerBase.h", "vtkSortDataArray.h", "vtkStdString.h", "vtkStringArray.h", "vtkStringManager.h", "vtkStringOutputWindow.h", "vtkStringToken.h", "vtkTimePointUtility.h", "vtkTimeStamp.h", "vtkUnsignedCharArray.h", "vtkUnsignedIntArray.h", "vtkUnsignedLongArray.h", "vtkUnsignedLongLongArray.h", "vtkUnsignedShortArray.h", "vtkVariant.h", "vtkVariantArray.h", "vtkVersion.h", "vtkVoidArray.h", "vtkWeakPointerBase.h", "vtkWeakReference.h", "vtkWindow.h", "vtkXMLFileOutputWindow.h", "vtkCriticalSection.h", "vtkAOSDataArrayTemplate.h", "vtkArrayDispatch.h", "vtkArrayInterpolate.h", "vtkArrayIteratorTemplate.h", "vtkArrayPrint.h", "vtkDenseArray.h", "vtkGenericDataArray.h", "vtkMappedDataArray.h", "vtkSOADataArrayTemplate.h", "vtkSparseArray.h", "vtkTypedArray.h", "vtkTypedDataArray.h", "vtkCommonCoreModule.h"], "licenses": []}}, "kits": {"VTK::Views": {"library_name": null, "enabled": false}, "VTK::Common": {"library_name": null, "enabled": false}, "VTK::OpenGL": {"library_name": null, "enabled": false}, "VTK::Rendering": {"library_name": null, "enabled": false}, "VTK::Rendering": {"library_name": null, "enabled": false}, "VTK::Rendering": {"library_name": null, "enabled": false}, "VTK::OpenGL": {"library_name": null, "enabled": false}, "VTK::OpenGL": {"library_name": null, "enabled": false}, "VTK::IO": {"library_name": null, "enabled": false}, "VTK::IO": {"library_name": null, "enabled": false}, "VTK::Parallel": {"library_name": null, "enabled": false}, "VTK::IO": {"library_name": null, "enabled": false}, "VTK::IO": {"library_name": null, "enabled": false}, "VTK::IO": {"library_name": null, "enabled": false}, "VTK::Parallel": {"library_name": null, "enabled": false}, "VTK::IO": {"library_name": null, "enabled": false}, "VTK::IO": {"library_name": null, "enabled": false}, "VTK::IO": {"library_name": null, "enabled": false}, "VTK::IO": {"library_name": null, "enabled": false}, "VTK::Rendering": {"library_name": null, "enabled": false}, "VTK::IO": {"library_name": null, "enabled": false}, "VTK::IO": {"library_name": null, "enabled": false}, "VTK::IO": {"library_name": null, "enabled": false}, "VTK::IO": {"library_name": null, "enabled": false}, "VTK::IO": {"library_name": null, "enabled": false}, "VTK::IO": {"library_name": null, "enabled": false}, "VTK::Parallel": {"library_name": null, "enabled": false}, "VTK::Parallel": {"library_name": null, "enabled": false}, "VTK::Interaction": {"library_name": null, "enabled": false}, "VTK::Imaging": {"library_name": null, "enabled": false}, "VTK::Imaging": {"library_name": null, "enabled": false}, "VTK::Imaging": {"library_name": null, "enabled": false}, "VTK::Imaging": {"library_name": null, "enabled": false}, "VTK::Imaging": {"library_name": null, "enabled": false}, "VTK::IO": {"library_name": null, "enabled": false}, "VTK::Views": {"library_name": null, "enabled": false}, "VTK::Interaction": {"library_name": null, "enabled": false}, "VTK::Rendering": {"library_name": null, "enabled": false}, "VTK::Rendering": {"library_name": null, "enabled": false}, "VTK::Imaging": {"library_name": null, "enabled": false}, "VTK::Interaction": {"library_name": null, "enabled": false}, "VTK::Filters": {"library_name": null, "enabled": false}, "VTK::Filters": {"library_name": null, "enabled": false}, "VTK::Filters": {"library_name": null, "enabled": false}, "VTK::Filters": {"library_name": null, "enabled": false}, "VTK::Filters": {"library_name": null, "enabled": false}, "VTK::Filters": {"library_name": null, "enabled": false}, "VTK::Filters": {"library_name": null, "enabled": false}, "VTK::Parallel": {"library_name": null, "enabled": false}, "VTK::Filters": {"library_name": null, "enabled": false}, "VTK::Imaging": {"library_name": null, "enabled": false}, "VTK::Filters": {"library_name": null, "enabled": false}, "VTK::Filters": {"library_name": null, "enabled": false}, "VTK::Filters": {"library_name": null, "enabled": false}, "VTK::Parallel": {"library_name": null, "enabled": false}, "VTK::Parallel": {"library_name": null, "enabled": false}, "VTK::Filters": {"library_name": null, "enabled": false}, "VTK::Filters": {"library_name": null, "enabled": false}, "VTK::OpenGL": {"library_name": null, "enabled": false}, "VTK::Parallel": {"library_name": null, "enabled": false}, "VTK::Parallel": {"library_name": null, "enabled": false}, "VTK::IO": {"library_name": null, "enabled": false}, "VTK::IO": {"library_name": null, "enabled": false}, "VTK::Parallel": {"library_name": null, "enabled": false}, "VTK::IO": {"library_name": null, "enabled": false}, "VTK::IO": {"library_name": null, "enabled": false}, "VTK::Filters": {"library_name": null, "enabled": false}, "VTK::Filters": {"library_name": null, "enabled": false}, "VTK::Imaging": {"library_name": null, "enabled": false}, "VTK::IO": {"library_name": null, "enabled": false}, "VTK::Rendering": {"library_name": null, "enabled": false}, "VTK::Rendering": {"library_name": null, "enabled": false}, "VTK::Rendering": {"library_name": null, "enabled": false}, "VTK::Filters": {"library_name": null, "enabled": false}, "VTK::Imaging": {"library_name": null, "enabled": false}, "VTK::Filters": {"library_name": null, "enabled": false}, "VTK::Filters": {"library_name": null, "enabled": false}, "VTK::Filters": {"library_name": null, "enabled": false}, "VTK::Common": {"library_name": null, "enabled": false}, "VTK::Filters": {"library_name": null, "enabled": false}, "VTK::Common": {"library_name": null, "enabled": false}, "VTK::Common": {"library_name": null, "enabled": false}, "VTK::Common": {"library_name": null, "enabled": false}, "VTK::Common": {"library_name": null, "enabled": false}, "VTK::Common": {"library_name": null, "enabled": false}, "VTK::Common": {"library_name": null, "enabled": false}, "VTK::Common": {"library_name": null, "enabled": false}}} \ No newline at end of file diff --git a/vtk/src/script.py b/vtk/src/script.py new file mode 100755 index 0000000..7e313ef --- /dev/null +++ b/vtk/src/script.py @@ -0,0 +1,226 @@ +#!/usr/bin/env python + +import collections +import json +import os +import re +from pathlib import Path + + +def get_program_parameters(argv): + import argparse + description = 'Generate a find_package(VTK COMPONENTS ...) command for CMake.' + epilogue = ''' +Uses modules.json and your source files to generate a + find_package(VTK COMPONENTS ...) command listing all the vtk modules + needed by the C++ source and header files in your code. + +Paths for more than one source path can be specified. + +Note than if there are spaces in the paths, enclose the path in quotes. + +If it is unable to find modules for your headers then + a list of these, along with the files they are in, is produced + so you can manually add the corresponding modules or rebuild VTK + to include the missing modules. + +You will need to manually add any third-party modules + (if used) to the find_package command. + ''' + parser = argparse.ArgumentParser(description=description, epilog=epilogue, + formatter_class=argparse.RawTextHelpFormatter) + parser.add_argument('json', default=['modules.json'], help='The path to the VTK JSON file (modules.json).') + parser.add_argument('sources', nargs='+', help='The path to the source files.') + parser.add_argument('-f', '--file', help='The file name to write the output too.') + args = parser.parse_args() + return args.json, args.sources, args.file + + +class Patterns: + header_pattern = re.compile(r'^#include *[<\"](\S+)[>\"]') + vtk_include_pattern = re.compile(r'^(vtk\S+)') + vtk_qt_include_pattern = re.compile(r'^(QVTK\S+)') + + +def get_headers_modules(json_data): + """ + From the parsed JSON data file make a dictionary whose key is the + header filename and value is the module. + :param json_data: The parsed JSON file modules.json. + :return: + """ + + # The headers should be unique to a module, however we will not assume this. + res = collections.defaultdict(set) + for k, v in json_data['modules'].items(): + if 'headers' in v: + for k1 in v['headers']: + res[k1].add(k) + return res + + +def get_vtk_components(jpath, paths): + """ + Get the VTK components + :param jpath: The path to the JSON file. + :param paths: The C++ file paths. + :return: + """ + + with open(jpath) as data_file: + json_data = json.load(data_file) + vtk_headers_modules = get_headers_modules(json_data) + + modules = set() + inc_no_mod = set() + inc_no_mod_headers = collections.defaultdict(set) + mod_implements = collections.defaultdict(set) + headers = collections.defaultdict(set) + + for path in paths: + if path.is_file(): + content = path.read_text().split('\n') + for line in content: + m = Patterns.header_pattern.match(line.strip()) + if m: + # We have a header name, split it from its path (if the path exists). + header_parts = os.path.split(m.group(1)) + m = Patterns.vtk_include_pattern.match(header_parts[1]) + if m: + headers[m.group(1)].add(path) + continue + m = Patterns.vtk_qt_include_pattern.match(header_parts[1]) + if m: + headers[m.group(1)].add(path) + for incl in headers: + if incl in vtk_headers_modules: + m = vtk_headers_modules[incl] + for v in m: + modules.add(v) + else: + inc_no_mod.add(incl) + inc_no_mod_headers[incl] = headers[incl] + + if headers: + for m in modules: + if not json_data['modules'][m]['implementable']: + continue + for i in json_data['modules']: + if i in modules: + continue + if m in json_data['modules'][i]['implements']: + # Suggest module i since it implements m + mod_implements[i].add(m) + + return modules, mod_implements, inc_no_mod, inc_no_mod_headers + + +def disp_components(modules, module_implements): + """ + For the found modules display them in a form that the user can + copy/paste into their CMakeLists.txt file. + :param modules: The modules. + :param module_implements: Modules implementing other modules. + :return: + """ + res = ['find_package(VTK\n COMPONENTS'] + for m in sorted(modules): + res.append(' {:s}'.format(m.split('::')[1])) + if module_implements: + keys = sorted(module_implements) + max_width = len(max(keys, key=len).split('::')[1]) + comments = [ + ' #', + ' # These modules are suggested since they implement an existing module.', + ' # You may need to uncomment one or more of these.', + ' # If vtkRenderWindow is used and you want to use OpenGL,', + ' # you also need the RenderingOpenGL2 module.', + ' # If vtkRenderWindowInteractor is used,', + ' # uncomment RenderingUI and possibly InteractionStyle.', + ' # If text rendering is used, uncomment RenderingFreeType', + ' #' + ] + res.extend(comments) + for key in keys: + res.append( + f' # {key.split("::")[1]:<{max_width}} # implements {", ".join(sorted(module_implements[key]))}') + res.append(')\n') + + return res + + +def disp_missing_components(inc_no_mod, inc_no_mod_headers): + """ + Display the headers along with the missing VTK modules. + + :param inc_no_mod: Missing modules. + :param inc_no_mod_headers: Headers with missing modules. + :return: + """ + if inc_no_mod: + res = ['' + '*' * 64, + 'You will need to manually add the modules that', + ' use these headers to the find_package command.', + 'These could be external modules not in the modules.json file.', + 'Or you may need to rebuild VTK to include the missing modules.', + '', + 'Here are the vtk headers and corresponding files:'] + sinmd = sorted(inc_no_mod) + for i in sinmd: + sh = sorted(list(inc_no_mod_headers[i])) + res.append(f'in {i}:') + for j in sh: + res.append(f' {j}') + res.append('*' * 64) + + return res + else: + return None + + +def main(json_path, src_paths, ofn): + jpath = Path(json_path) + if jpath.is_dir(): + jpath = jpath / 'modules.json' + if not jpath.is_file(): + print(f'Non existent JSON file: {jpath}') + return + + paths = list() + valid_ext = ['.h', '.hxx', '.cxx', '.cpp', '.txx'] + path_list = list() + for fn in src_paths: + path = Path(fn) + if path.is_file() and path.suffix in valid_ext: + paths.append(path) + elif path.is_dir(): + for e in valid_ext: + path_list += list(Path(fn).rglob(f'*{e}')) + program_path = Path(__file__) + for path in path_list: + if path.resolve() != program_path.resolve(): + paths.append(path) + else: + print(f'Non existent path: {path}') + + modules, mod_implements, inc_no_mod, inc_no_mod_headers = get_vtk_components(jpath, paths) + + res = '\n'.join(disp_components(modules, mod_implements)) + if inc_no_mod: + res += '\n'.join(disp_missing_components(inc_no_mod, inc_no_mod_headers)) + + if ofn: + path = Path(ofn) + if path.suffix == '': + path = Path(ofn).with_suffix('.txt') + path.write_text(res) + else: + print(res) + + +if __name__ == '__main__': + import sys + + json_paths, src_paths, ofn = get_program_parameters(sys.argv) + main(json_paths, src_paths, ofn)